你是否了解 Java 中的 Lambda 表达式？以及它的变量捕获机制？

迷南。 2023-09-27 21:46 10阅读 0赞

# 1. Lambda 表达式 #

# 1.1 语法 #

Lambda表达式是Java SE 8引入的一种函数式编程语法，它的语法形式是：

rust复制代码(parameters) -> expression
    
    (parameters) -> { statements; }

*  parameters是参数列表，可以是空的或者包含一个或多个参数。如果有多个参数，用逗号分隔。
 *  \->是Lambda运算符，将参数列表和Lambda表达式的主体分开。
 *  expression是一个表达式，可以是常量、变量、方法调用、操作符、Lambda表达式或其他表达式。
 *  \{ \}中的语句是Lambda表达式的主体，可以是一个或多个语句，也可以是一个代码块，是函数式接口里方法的实现。

Java复制代码// 1. 不需要参数,返回值为 2
    () -> 2
    // 2. 接收一个参数(数字类型),返回其2倍的值
    x -> 2 * x
    // 3. 接受2个参数(数字),并返回他们的和
    (x, y) -> x + y
    // 4. 接收2个int型整数,返回他们的乘积
    (int x, int y) -> x * y
    // 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
    (String s) -> System.out.print(s)

# 1.2 函数式接口 #

Lambda表达式必须搭配函数式接口使用。

**函数式接口定义：一个接口有且只有一个抽象方法 。**

形如下面的接口：

java复制代码interface FunctionalInterface{
    
        void print();
        
        //可以加 default 方法，只要保证接口中只有一个抽象方法就行了
        default void test2() {
            System.out.println("JDK1.8新特性，default默认方法可以有具体的实现");
        }
    }

# 1.3 Lambda 的使用 #

现有如下的函数接口：

java复制代码//无返回值无参数
    interface NoParameterNoReturn {
        void test();
    }
    
    //无返回值一个参数
    interface OneParameterNoReturn {
        void test(int a);
    }
    
    //无返回值多个参数
    interface MoreParameterNoReturn {
        void test(int a,int b);
    }
    
    //有返回值无参数
    interface NoParameterReturn {
        int test();
    }
    
    //有返回值一个参数
    interface OneParameterReturn {
        int test(int a);
    } 
    
    //有返回值多参数
    interface MoreParameterReturn {
        int test(int a,int b);
    }

java复制代码public static void main(String[] args) {
    
        //无返回值无参数
        NoParameterNoReturn noParameterNoReturn = ()-> System.out.println("通过Lambda的方式：这是 test 方法");
        NoParameterNoReturn noParameterNoReturn1 = new NoParameterNoReturn() {
            @Override
            public void test() {
                System.out.println("通过匿名内部类的方式：这是 test 方法");
            }
        };
        noParameterNoReturn.test();
        noParameterNoReturn1.test();
    }
    结果：
    通过Lambda的方式：这是 test 方法
    通过匿名内部类的方式：这是 test 方法

Lambda 与匿名内部类非常相似，它们的作用都是创建一个匿名类并重写里面的方法，但是 Lambda 的形式比较简单，但是只适用于函数接口；而匿名内部类可用于接口中多个抽象方法的情况。

java复制代码public class Main {
        public static void main(String[] args) {
    
            //无返回值无参数
            NoParameterNoReturn noParameterNoReturn = ()-> System.out.println("通过Lambda的方式：这是 test 方法");
            noParameterNoReturn.test();
    
            //无返回值一个参数，可以省略：a->System.out.println(a);
            OneParameterNoReturn oneParameterNoReturn = (int a)-> System.out.println(a);
            oneParameterNoReturn.test(100);
    
            //无返回值多个参数，int 可以省略：(a,b)-> System.out.println("a: " + a+" " + "b: " + b);
            MoreParameterNoReturn moreParameterNoReturn = (int a,int b)-> System.out.println("a: " + a+" " + "b: " + b);
            moreParameterNoReturn.test(200,300);
    
            //有返回值无参数，return 可以省略： ()->100;
            NoParameterReturn noParameterReturn = ()-> {
                int a = 100;
                return a;
            };
            System.out.println(noParameterReturn.test());
    
            //有返回值多参数
            MoreParameterReturn moreParameterReturn = (int a,int b)->{
                return a + b;
            };
            System.out.println(moreParameterReturn.test(100, 200));
        }
    }

1.  参数类型可以省略，如果需要省略，每个参数的类型都要省略。
2.  参数的小括号里面只有一个参数，那么小括号可以省略。
3.  如果方法体当中只有一句代码，那么大括号可以省略。
4.  如果方法体中只有一条语句，其是return语句，那么大括号可以省略，且去掉return关键字。

# 2. 变量捕获 #

# 2.1 匿名内部类的变量捕获 #

所谓变量捕获就是：匿名内部类中访问所在方法或代码块中的局部变量，这个过程被称为“变量捕获”。

typescript复制代码public static void main(String[] args) {
        //变量捕获
        int a = 100;
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
            @Override
            public void test() {
                //捕获 a 变量
                System.out.println(a);   
            }
        };
        noParameterNoReturn.test();
    }
    结果：
    100

但是，只有在局部变量是“有效的最终变量”时，匿名内部类才能够引用它。如果局部变量不是有效的最终变量，则无法在匿名内部类中引用它，会导致编译错误。

有效的最终变量指的是一个在**生命周期中没有被修改过的局部变量**，它可以被认为是一个常量。

![format_png][]

# 2.2 Lambda 的变量捕获 #

同样的，Lambda 的变量捕获也是只有在局部变量是“有效的最终变量”时，才能够引用它。

java复制代码public static void main(String[] args) {
        //变量捕获
        int a = 100;
        
        NoParameterNoReturn noParameterNoReturn = ()->{
            //捕获 a 变量
            System.out.println(a);
        };
        noParameterNoReturn.test();
    }
    结果：
    100

![format_png 1][]

# 2.3 匿名内部类的变量捕获 与 Lambda 的变量捕获的区别 #

区别：**Lambda表达式可以捕获外面的this，而匿名内部类无法直接捕获外面的this。**

在Lambda表达式中，**this关键字引用的是Lambda表达式所在的类的实例**，而不是Lambda表达式内部的类的实例。这个特性被称为“闭包”。

**匿名内部类中的this关键字引用的是匿名内部类的实例**，而不是外部类的实例。

java复制代码public class Student {
        //外部类的属性
        String name = "Student";
        int age;
    
         NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
            //内部类自己的属性
            String name = "hello";
            @Override
            public void test() {
                System.out.println(this.name);
            }
        };
    
         NoParameterNoReturn noParameterNoReturn2 = ()->{
            String name = "hello";
            System.out.println(this.name);
        };
    
        public static void main(String[] args) {
            Student student = new Student();
            student.noParameterNoReturn.test();
            student.noParameterNoReturn2.test();
        }
    }

结果：

![format_png 2][]

如果想让匿名内部类的捕获外面的 this，就需要使用外部类的类名或对象引用来访问。。

# 3. Lambda 在集合当中的使用 #

<table> 
 <tbody> 
  <tr> 
   <td> <p>对应的接 口</p> </td> 
   <td> <p>新增的方法</p> </td> 
  </tr> 
  <tr> 
   <td> <p>Collection</p> </td> 
   <td> <p>removeIf() spliterator() stream() parallelStream() forEach()</p> </td> 
  </tr> 
  <tr> 
   <td> <p>List</p> </td> 
   <td> <p>replaceAll() sort()</p> </td> 
  </tr> 
  <tr> 
   <td> <p>Map</p> </td> 
   <td> <p>getOrDefault() forEach() replaceAll() putIfAbsent() remove() replace() computeIfAbsent() computeIfPresent() compute() merge()</p> </td> 
  </tr> 
 </tbody> 
</table>

# 3.1 Collection 接口中的 forEach() 方法 #

这个方法是在接口 Iterable 当中的：

![format_png 3][]

这个方法表示用于对集合中的每个元素执行指定的操作。

java复制代码public class Test {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("Hello");
            list.add("bit");
            list.add("hello");
            list.add("lambda");
    
            //匿名内部类 遍历 list
            list.forEach(new Consumer<String>() {
                //执行的操作
                @Override
                public void accept(String s) {
                    System.out.println(s);
                }
            });
    
            System.out.println("---------------------");
            
            //Lambda 遍历 list
            list.forEach((String s)->{
                System.out.println(s);
            });
        }
    }
    结果：
    Hello
    bit
    hello
    lambda
    ---------------------
    Hello
    bit
    hello
    lambda

# 3.2 List 接口中的 sort() 方法 #

java复制代码public class Test {
        public static void main(String[] args) {
    
            List<String> list = new ArrayList<>();
            list.add("Hello");
            list.add("bit");
            list.add("hello");
            list.add("lambda");
            //匿名内部类
            list.sort(new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    return o1.compareTo(o2);
                }
            });
            System.out.println(list);
    
    
            List<String> list2 = new ArrayList<>();
            list2.add("hello");
            list2.add("lambda");        
            list2.add("Hello");
            list2.add("bit");
            //Lambda
            list2.sort((o1,o2)->o1.compareTo(o2));
            System.out.println(list2);
        }
    }

# 3.3 Map接口的 forEach() 方法 #

这个方法的源码：

![format_png 4][]

java复制代码public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "hello");
        map.put(2, "bit");
        map.put(3, "hello");
        map.put(4, "lambda");
        //匿名内部类
        map.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer integer, String s) {
                System.out.println(integer + "=" + s);
            }
        });
        System.out.println();
        
        //Lambda
        map.forEach((integer,s)->{System.out.println(integer + "=" + s);});
    }
    结果：
    1=hello
    2=bit
    3=hello
    4=lambda
    
    1=hello
    2=bit
    3=hello
    4=lambda

[format_png]: https://img-blog.csdnimg.cn/img_convert/8f1619338cdc07438568976b26d4c225.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/cbc32ee74bcaee3b69c37b261f5d54c8.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/4104cd4f3ce7f55a04dd800eeb338364.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/b4f34fc22912ae11da4ec465b2c50d07.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/32c241eef6868b35269f52de53ca738e.webp?x-oss-process=image/format,png