Java学习十四—Java8特性之Lambda表达式

==========================

一、简介

====

Java 8 引入了 Lambda 表达式，它是一种更简洁、更便于使用的函数式编程特性。Lambda 表达式允许将函数作为方法的参数（函数式接口的实例）传递给某个方法，或者将代码像数据一样进行传递。

‍

lambda是一个匿名函数，我们可以吧lambda表达式理解为是一段可以传递的代码。使用它可以写出更简洁，更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

lambda接口的实质：作为函数式接口的实例,关键是这个匿名内部类的简化，省略。

‍

‍

二、语法

2.1基本语法

Lambda 表达式的基本语法如下：

(parameters) -> expression
或者
(parameters) -> { statements; }

其中：

• 参数列表：可以为空，也可以包含一个或多个参数。例如 (int a, int b)​ 或者 (String s)​。
• 箭头 -> ​：箭头将参数列表与 Lambda 表达式的主体分隔开来。

• 主体：

  • 如果主体只有一条语句，可以直接写表达式，不需要大括号 {}​。
  • 如果主体有多条语句，需要使用大括号 {}​ 将语句块括起来。

‍

2.2Lambda表达式中推荐变量名

在Lambda表达式中，变量名的选择同样应该考虑可读性和代码的清晰度。以下是一些在Lambda表达式中常用的推荐变量名：

1. e​: 通常用于表示集合中的元素。
2. x​, y​, z​: 用作通用的变量名，可以表示任意类型的对象。
3. p​, q​: 可以用于表示方法的参数。
4. i​, j​, k​: 用于表示循环计数器。
5. result​, output​: 用于表示Lambda表达式的返回值。
6. predicate​: 表示一个谓词（Predicate）参数，用于筛选操作。
7. consumer​: 表示一个消费者（Consumer）参数，用于对元素进行处理。
8. function​: 表示一个函数（Function）参数，用于转换或映射操作。
9. supplier​: 表示一个供应者（Supplier）参数，用于生成结果或对象。

这些变量名是一种约定俗成的习惯，使用它们可以提高代码的可读性和可维护性。当然，具体的变量名选择仍然取决于上下文和个人偏好，关键是确保变量名能够准确地描述其含义和作用

‍

在Lambda表达式中，你可以使用任何合法的标识符作为变量名，包括使用o​来表示集合中的元素。然而，建议在可读性和代码清晰度方面选择更有描述性的变量名。

选择一个有意义的变量名可以使代码更易于理解和维护。在表示集合中的元素时，通常建议选择具有描述性的名称，以便更清晰地表示元素的含义。

例如，如果集合中的元素是商品对象，则可以将变量名命名为product​；如果集合中的元素是订单对象，则可以将变量名命名为order​。这样可以提高代码的可读性，使其他人更容易理解你的代码意图。

List<Product> products = ...
products.forEach(product -> {
    // 对每个商品进行操作
});
​

‍

2.3示例 1：简单的输出

// 无参数的Lambda表达式
() -> System.out.println("Hello, Lambda!");

‍

2.4示例 2：带参数的Lambda表达式

// 带一个参数的Lambda表达式
(String s) -> System.out.println(s)
​
// 带两个参数的Lambda表达式
(int a, int b) -> a + b

‍

2.5示例 3：带返回值的Lambda表达式

// Lambda表达式的主体是一个表达式，直接返回结果
(int a, int b) -> a * b
​
// Lambda表达式的主体是一个代码块，可以包含多条语句
(int a, int b) -> {
    if (a > b)
        return a;
    else
        return b;
}

‍

‍

三、示例

3.1Runnable接口案例

传统方式

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
​
@SpringBootTest
class Lamada01ApplicationTests {
​
    @Test
    void contextLoads() {
    }
​
    @Test
    public void test01(){
        Runnable r1=new Runnable() {
            @Override
            public void run() {
                System.out.println("好好学习，天天向上");
            }
        };
​
        r1.run();
    }
}

​

‍

‍

lambda方式

    @Test
    public void test02(){
        Runnable r2=()-> System.out.println("北京天安门");
        r2.run();
    }

​

‍

分析

​

‍

​

‍

3.2比较大小案例

传统方式

    @Test
    public void test03(){
        Comparator<Integer> comparator=new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
​
        int compare = comparator.compare(12, 21);
        System.out.println(compare);
    }

​

‍

lambda方式

    @Test
    public void test04(){
        Comparator<Integer> comparator=(o1,o2)->Integer.compare(o1,o2);
​
        int compare = comparator.compare(32, 35);
        System.out.println(compare);
​
    }

​

‍

分析

​

‍

3.3Consumer案例

传统方式

    @Test
    public void test05(){
        Consumer<String> consumer=new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
​
        consumer.accept("25533/");
​
    }

​

‍

lambda方式

    public void test06(){
        Consumer<String> consumer=s -> System.out.println(s);
​
        consumer.accept("/85572");
    }

​

‍

分析

​

​

​

‍

3.4排序案例

我们先来看一段老版本的示例代码，其对一个含有字符串的集合进行排序：Collections 工具类提供了静态方法 sort 方法，入参是一个 List 集合，和一个 Comparator 比较器，以便对给定的 List 集合进行 排序。上面的示例代码创建了一个匿名内部类作为入参，这种类似的操作在我们日常的工作中随处可见。

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
​
public class HelloWorld{
​
     public static void main(String []args){
    
        List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
    
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return a.compareTo(b);
            }
        });
    
        System.out.println(names);
    
     }
}

​

‍

Lambda 表达式

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
​
public class HelloWorld{
​
     public static void main(String []args){
    
        List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
    
    
        Collections.sort(names, (String a, String b) -> {
            return a.compareTo(b);
        });
    
    
        System.out.println(names);
    
     }
}

​

‍

分析

    @Test
    public void Test07(){
        List<String> names= Arrays.asList("peter", "anna", "mike", "xenia");
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
​
        System.out.println(names);
    }

​

‍

‍

    @Test
    public void Test08(){
        List<String> names= Arrays.asList("peter", "anna", "mike", "xenia");
        Collections.sort(names, (String o1,String o2)->{
            return o1.compareTo(o2);
        } );
​
        System.out.println(names);
    }

​

‍

​

‍

3.5使用 Lambda 表达式与 Streams API

Java 8 的 Streams API 允许你以声明性方式处理集合。以下是使用 Lambda 表达式过滤和处理集合的示例：

List<String> filteredNames = names.stream()  // 创建 Stream
    .filter(name -> name.length() > 4)        // 使用 Lambda 表达式过滤
    .collect(Collectors.toList());             // 收集结果
System.out.println(filteredNames); // 输出 [Peter, Kim]

‍

原文链接: https://juejin.cn/post/7388091090350489626