【Java】：lambda 表达式

📃个人主页：island1314

🔥个人专栏：java学习

⛺️ 欢迎关注：👍点赞 👂🏽留言 😍收藏 💞 💞 💞

1. 背景 🚀

🔥 Lambda 表达式是JDK8新增的特性，Lambda 表达式可以取代大部分匿名内部类，写出更优雅的Java代码，尤其在集合的遍历和其他集合操作中，可以将函数作为一个方法的参数，也就是函数作为参数传递到方法中，极大地优化代码结构JDK也提供了大量的内置函数式接口供开发者使用，使得 Lambda 表达式的运用更加方便、高效。

Lambda 表达式（Lambda expression）可以看作是一个匿名函数，基于数学中的λ演算得名，也可称为闭包（Closure）
Lambda 表达式的使用场景：用以简化接口实现

2. 基本使用 🖊

🥑 1. 语法格式

🎈 Lambda表达式的基本语法：由 参数列表（parameters）、箭头符号(一>) 和方法体（expression 或者 statements）组成

paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
->：可理解为“被用于” 的意思
方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。
- 代码块可返回一个值或者什么都不返回，这里的代码块等同于方法的方法体。
- 如果是表达式，也可以返回一个值或者什么都不返回。
- 其中，表达式会被执行，然后返回执行结果；语句块中的语句会被依次执行，就像方法中的语句一样。

Lambda表达式常用的语法格式如下所示：

语法格式	描述
() -> System.out.println("Hello IsLand1314");	无参数，无返回值
(x) -> System.out.println(x);	有一个参数，无返回值
x -> System.out.println(x);	若只有一个参数，小括号可以省略不写
Comparator<Integer>com = (x，y) -> { System.out.priniln("函数式接口"); return Integer,compare(x，y); };	有两个以上的参数，有返回值，并且Lambda方法体中有多条语句
Comparator<Integer>com = (x，y) -> Integer,compare(x，y););	若Lambda方法体中只有一条语句，return和大括号都可以省略不写
(Integer x, Integer y) -> Integer.compare(x, y):	Lambda表达式的参数列表的数据类型可以省略不写，因为 Java 虚拟机的编译器可以通过上下文推断出数据类型，即 "类型推断"

🥑 2. 函数式接口

🥑 虽然说，Lambda 表达式可以在⼀定程度上简化接口的实现。但是，并不是所有的接口都可以使用lambda表达式来简洁实现的。

🧃 Lambda 表达式毕竟只是⼀个匿名方法。当实现的接口中的方法过多或者多少的时候，lambda表达式都是不适用的。

lambda表达式，只能实现函数式接口，函数式接口定义：一个接口有且只有一个抽象方法

如下：

//有且只有一个实现类必须要实现的抽象方法，所以是函数式接口
interface Test{
    public void test();
}

⼀个接口中，要求实现类必须实现的抽象方法，有且只有⼀个！这样的接口，就是函数式接口

补充：

🔖 @FunctionalInterface

是⼀个注解，用在接口之前，判断这个接口是否是⼀个函数式接口。
如果是函数式接口，没有任何问题。如果不是函数式接口，则会报错
功能类似于 @Override

@FunctionalInterface
interface NoParameterNoReturn {
	//注意：只能有一个方法
	void test();
}

但是这种方式也是可以的：

@FunctionalInterface
interface NoParameterNoReturn {
	void test();
	default void test2() {
		System.out.println("JDK1.8新特性，default默认方法可以有具体的实现");
	}
}

注意：

如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口
如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的
1. 所以，从某种意义上来说，只要你保证你的接口中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的
Lambda 表达式只能简化函数式接口的匿名内部类的写法

🥑 3. 具体使用

🌈 我们在上面提到过，Lambda表达式本质是一个匿名函数，函数的方法是：返回值方法名参数列表方法体

在 Lambda 表达式中我们只需要关心：参数列表方法体

首先，我们实现准备好几个接口：

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//无返回值两个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}

//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多个参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}

我们在上面提到过，Lambda可以理解为：Lambda就是匿名内部类的简化，实际上是创建了一个类，实现了接口，重写了接口的方法。

没有使用 Lambda 表达式的时候的调用方式

NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
  @Override
  public void test() {
    System.out.println("hello");
 }
};
noParameterNoReturn.test();

使用 Lambda 表达式的时候的调用方式



public class Test {
    public static void main(String[] args) {
         NoParameterNoReturn n = ()->{
            System.out.println("无参数无返回值");
        };
        n.test();

        OneParameterNoReturn o = (a)-> {
            System.out.println("无返回值一个参数 "+a);
        };
        o.test(666);
        MoreParameterNoReturn m = (int a,int b)->{
            System.out.println("无返回值两个参数 "+a+" "+b);
        };
        m.test(666,999);

        System.out.println("================");


        NoParameterReturn n1 = ()->{
            return 666;
        };

        int ret1 = n1.test();
        System.out.println(ret1);
        System.out.println("================");
        OneParameterReturn o1 = (int a)->{
            return a;
        };
        int ret2 = o1.test(999);
        System.out.println(ret2);
        System.out.println("================");
        MoreParameterReturn m1 = (int a,int b)-> {
            return a+b;
        };
        int ret3 = m1.test(10,90);
        System.out.println(ret3);

    }
}

// 打印结果：
无参数无返回值
无返回值一个参数 666
无返回值两个参数 666 999
================
666
================
999
================
100

🔥 Lambda 表达式的语法还可以精简，显得非常有逼格，但是可读性就非常差，之前我们上面说过 Lambda 表达式的语法格式表格。

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

public class Test {
    	public static void main(String[] args) {
        MoreParameterNoReturn moreParameterNoReturn = (a, b)->{
            System.out.println("无返回值多个参数，省略参数类型："+a+" "+b);
        };
        moreParameterNoReturn.test(20,30);
        OneParameterNoReturn oneParameterNoReturn = a ->{
            System.out.println("无参数一个返回值,小括号可以省略："+ a);
        };
        oneParameterNoReturn.test(10);
        NoParameterNoReturn noParameterNoReturn = ()->System.out.println("无参数无返回值，方法体中只有 一行代码");
        noParameterNoReturn.test();
        //方法体中只有一条语句，且是return语句
        NoParameterReturn noParameterReturn = ()-> 40;
        int ret = noParameterReturn.test();
        System.out.println(ret);
    }
}

// 结果如下：
无返回值多个参数，省略参数类型：20 30
无参数一个返回值,小括号可以省略：10
无参数无返回值，方法体中只有 一行代码
40

可能还不直观，一般来说，大家只要向下面这样使用就行

interface T{
    public int test(String name,int age);
}

public class Test {
    	public static void main(String[] args) {
        T t = (name, age) -> {
            System.out.println(name + "  "+ age + " 岁了");
            return age + 1;
        };

        int age = t.test("qian", 18);
        System.out.println(age);
    }
}

// 输出如下：
qian  18 岁了
19

4. 变量捕获

🔥 Lambda 表达式中存在变量捕获，了解了变量捕获之后，我们才能更好的理解 Lambda 表达式的作用域。Java当中的匿名类中，会存在变量捕获。

🥝 1. 匿名内部类变量捕获

匿名内部类就是没有名字的内部类。在前面的博客——>【Java 学习】：内部类详解中提到了匿名内部类中变量的捕获。

而我们这里只是为了说明变量捕获，所以，匿名内部类只要会使用就好
匿名内部类中：一定是程序在运行的过程当中没有发生改变的量

那么下面我们来，下面就来看看匿名内部类的使用及其变量捕获


//有参 有返回值
class T{
   public void func(){
       System.out.println("func()");
   }
}
public class Test {
    	public static void main(String[] args) {
        int a = 100;
        new T(){
            // a = 666; // 如果把 a 在匿名内部类修改，就会报错
            @Override
            public void func() {
                System.out.println("a= " + a);
            }}.func();
    }
}

// 输出
a= 100

注意：上面在匿名内部类注释的 a = 666，代码中会报错

原因如下：

匿名内部类中可以访问外部方法的局部变量（如 a），但这个变量必须是 final 或隐式 final，这里的 a 由于没有被修改，因此是隐式 final，所以可以安全访问。
你注释掉的代码 a = 666; 会导致编译错误，因为局部变量 a 在 Lambda 或匿名内部类中不可修改，必须保持其初始值

🥝 2. Lambda的变量捕获

在 Lambda 表达式当中也可以进行变量的捕获

Lambda 表达式的变量捕获，同样也是不能捕获放生改变的，如果发生改变就会报错

具体我们看一下代码

public class Test {
    @FunctionalInterface
    interface NoParameterNoReturn {
        void test();
    }
    public static void main(String[] args) {
        int a = 10;
        NoParameterNoReturn noParameterNoReturn = ()->{
        // a = 99; error
        System.out.println("捕获变量："+a);
        };
        noParameterNoReturn.test();
    }
}

注意事项：

这里类似于局部内部类、匿名内部类，依然存在闭包的问题。
如果在 Lambda 表达式中，使用到了局部变量，那么这个局部变量会被隐式的声明为 final。是⼀个常量，不能修改值。

5. 函数引用

💦 Lambda 表达式是为了简化接口的实现的。在Lambda 表达式中，不应该出现比较复杂的逻辑。

如果在 Lambda 表达式中出现了过于复杂的逻辑，会对程序的可读性造成非常大的影响。
如果在 Lambda 表达式中需要处理的逻辑比较复杂，⼀般情况会单独的写⼀个方法。
在 Lambda 表达式中直接引用这个方法即可。

函数引用：引用⼀个已经存在的方法，使其替代lambda表达式完成接口的实现

🦄 1. 静态方法引用

语法

类::静态方法

案例如下：

interface T{
    int test(int a,int b);
}

class Cal{
    public static int add(int a,int b ){
        return a + b;
    }
}

public class Test {
    public static void main(String[] args) {
        //实现多个参数，一个返回值的接口
        //对一个静态方法的引用，语法：类::静态方法
        T t = Cal::add;
        System.out.println(t.test(4,5));
    }
}

// 输出结果：9

注意事项

在引用的方法后面，不要添加小括号。
引用的这个方法，参数（数量、类型）和返回值，必须要跟接口中定义的⼀致

🦄 2. 非静态方法引用

语法

对象::非静态方法

案例如下：

interface T{
    int test(int a,int b);
}

public class Test {
    private static class Cal{
        public int add(int a, int b) {
            return a+b;
         }
    }
    public static void main(String[] args) {
        // //对非静态方法的引用，需要使用对象来完成

        // 两种方法
        // 方法一
        Cal cal = new Cal();
        T t = cal::add;

        // 方法二：
        //T t = new Cal()::add;
        System.out.println(t.test(4,5));
    }
}

注意事项

在引用的方法后面，不要添加小括号。
引用的这个方法，参数（数量、类型）和返回值，必须要跟接口中定义的⼀致

🦄 3. 构造方法引用

使用场景

如果某⼀个函数式接口中定义的方法，仅仅是为了得到⼀个类的对象。此时我们就可以使用构造方法的引用，简化这个方法的实现。

语法：

类名::new

案例如下：

public class Test {
    private static class Student {
        String name;
        int age;

        //无参构造
        public Student() {
            System.out.println("学生对象的无参构造");
        }

        //有参构造
        public Student(String name, int age) {
            System.out.println("学生对象的有参构造");
            this.name = name;
            this.age = age;
        }
    }

    //定义一个函数式接口,用以获取无参的对象
    @FunctionalInterface
    private interface GetStudent {
        //若此方法仅仅是为了获得一个Student对象，而且通过无参构造去获取一个Student对象作为返回值
        Student s();
    }

    //定义一个函数式接口,用以获取有参的对象
    @FunctionalInterface
    private interface GetStudentWithParameter {
        //若此方法仅仅是为了获得一个Student对象，而且通过有参构造去获取一个Student对象作为返回值
        Student a(String name, int age);
    }

    // 测试
    public static void main(String[] args) {
        //lambda表达式实现接口
        GetStudent lm = Student::new; //引用到学生类中的无参构造方法，获取到一个学生对象
        Student s1 = lm.s();
        System.out.println("学生的名字：" + s1.name + " 学生的年龄：" + s1.age); //学生的名字：null 学生的年龄：0

        System.out.println("--------------------------------");

        GetStudentWithParameter lm2 = Student::new;//引用到Student类中的有参构造，来获取一个学生对象
        Student s2 = lm2.s("IsLand", 18);
        System.out.println("学生的名字：" + s2.name + " 学生的年龄：" + s2.age);//学生的名字：IsLand 学生的年龄：18

    }
}

这里 Student::new 是对 Student 类中无参构造方法的引用，使用它来实现 GetStudent 接口的 test() 方法。因此，lm.test() 会调用 Student 类的无参构造器，返回一个 Student 对象。在这种情况下，Student 对象的 name 和 age 字段会保持默认值：null 和 0。

注意事项：可以通过接口中的方法的参数，区分引用不同的构造方法。

6. Lambda 在集合中的使用

🔥 为了能够让Lambda和Java的集合类集更好的一起使用，集合当中，也新增了部分接口，以便与Lambda表达式对接。

多提一句：要用Lambda遍历集合就一定要看懂源码

注意：Collection的forEach()方法是从接口 java.lang.Iterable 拿过来的

🐇 1. Collection 接口

forEach() 方法演示

🥥 forEach()方法遍历集合。如果要打印元素，它需要的实现 Consumer接口，同时要实现重写 accept() 方法，它会把数组里的每一个元素都交给 accept()方法。

该方法在接口 Iterable 当中，原型如下：

default void forEach(Consumer< ? super T> action) {
	Objects.requireNonNull(action);
	for (T t : this) {
		action.accept(t);
	}
}

该方法表示：对容器中的每个元素执行action指定的动作

public class Test {
    public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("Hello");list.add("IsLand");
		list.add("Hello");list.add("lambda");

		// 两种遍历遍历
		list.forEach(new Consumer<String>() {
			@Override
				public void accept(String str) {
				//简单遍历集合中的元素。
				System.out.print(str + " ");
			}
		});
		System.out.println();
		System.out.println("----------------------------");
		//表示调用一个，不带有参数的方法，其执行花括号内的语句，为原来的函数体内容。
		list.forEach(s -> {System.out.print(s + " ");});
	}
}

// 输出：
Hello IsLand Hello lambda 
----------------------------
Hello IsLand Hello lambda

🐇 2. List 接口

sort()方法的演示

sort方法源码：该方法根据c指定的比较规则对容器元素进行排序

public void sort(Comparator< ? super E> c) {
	final int expectedModCount = modCount;
	Arrays.sort((E[]) elementData, 0, size, c);
	if (modCount != expectedModCount) {
		throw new ConcurrentModificationException();
	}
	modCount++;
}

使用示例：

public class Test {
    public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("Hello");list.add("IsLand");
		list.add("Hello");list.add("lambda");

		// 两种排序方式
		list.sort(new Comparator<String>() {
			@Override
				public int compare(String s1, String s2) {
				//注意这里比较长度
				return s1.length() - s2.length();
			}
		});
		System.out.println(list);

		System.out.println("----------------------------");

		// 修改为 Lambda 表达式
		//调用带有2个参数的方法，且返回长度的差值
		list.sort((s1, s2)->s1.length() - s2.length());
		System.out.println(list);
	}
}

// 输出如下：
[Hello, Hello, IsLand, lambda]
----------------------------
[Hello, Hello, IsLand, lambda]

🐇 3. Arrays 接口

public class Test {
    public static void main(String[] args) {
		String[] a = {"program", "creek", "is", "a", "java", "site"};
		Arrays.sort(a, (m,n)->Integer.compare(m.length(), n.length())) ;
		System.out.println("Lambda 语句体只有一条语句，参数类型可推断: " + Arrays.toString(a));

		Arrays.sort(a, (String m, String n)->{
			if( m.length() > n.length()) return -1;
			else return 0;
		});
		System.out.println("Lambda 语句体有多条语句，参数类型可推断: " + Arrays.toString(a));
	}
}

// 输出结果如下：
Lambda 语句体只有一条语句，参数类型可推断: [a, is, java, site, creek, program]
Lambda 语句体有多条语句，参数类型可推断: [program, creek, java, site, is, a]

🐇 4. Map 接口

HashMap 的 forEach()
该方法原型如下：

default void forEach(BiConsumer< ? super K, ? super V> action) {
	Objects.requireNonNull(action);
	for (Map.Entry<K, V> entry : entrySet()) {
		K k;
		V v;
		try {
			k = entry.getKey();
			v = entry.getValue();
		}
		catch (IllegalStateException ise) {
			// this usually means the entry is no longer in the map.
			throw new ConcurrentModificationException(ise);
		}
		action.accept(k, v);
	}
}

作用是对Map中的每个映射执行action指定的操作

代码示例

public class Test {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "Hello");map.put(2, "IsLand");
        map.put(3, "Hello");map.put(4, "lambda");

        map.forEach(new BiConsumer<Integer, String>(){
            @Override
            public void accept(Integer k, String v){
                System.out.println(k + "=" + v);
            }
        });
        System.out.println("--------------------------------------");
		// 改为 Lambda 表达式
		map.forEach((k, v) -> System.out.println(k + "=" + v));
    }
}

// 运行结果如下：
1=Hello
2=IsLand
3=Hello
4=lambda
--------------------------------------
1=Hello
2=IsLand
3=Hello
4=lambda

7. 小结

Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的简洁。缺点也很明显，代码不易读

优点：

简化代码：使得代码更加简洁，尤其是在处理集合、并行处理和事件监听时。
增强可读性：通过将代码行为和逻辑传递给方法，减少了冗长的匿名类实现。
支持函数式编程：Lambda 使得 Java 更加符合函数式编程范式，增强了代码的表达能力。
能够与 Stream API 结合：Lambda 表达式与 Java 8 引入的 Stream API 配合使用，可以更方便地进行集合的操作（如过滤、映射、聚合等）。

缺点：

调试困难：Lambda 表达式是匿名的，难以在调试时逐步跟踪。尤其是复杂的 Lambda 表达式可能使得代码的可调试性下降。
过度使用 Lambda：如果 Lambda 表达式过于复杂或滥用，可能会导致代码的可读性下降，尤其是当 Lambda 的行为变得不直观时。
性能问题：虽然 Lambda 表达式的引入让代码更加简洁，但在某些情况下，Lambda 的性能可能不如传统的匿名类或普通方法调用，因为每次调用 Lambda 都涉及到对象的创建（比如生成函数式接口的代理）。

Lambda表达式有什么使用前提：必须是接口的匿名内部类，接口中只能有一个抽象方法