一文彻底搞懂Lambda表达式

前置

学习Lambda首先得知道什么是匿名实现类，具体可以看我上一篇的文章什么是匿名实现类

定义

Lambda表达式是Java编程语言中引入的一种新特性，它允许您以更简洁、更具可读性的方式来定义匿名函数或代码块，从而更容易地实现函数式编程的概念。Lambda表达式通常用于替代匿名内部类，特别是在需要传递函数作为参数的情况下，例如在集合操作中使用。

使用举例

原始的匿名实现类写法

Comparator<Integer> com1 = new Comparator<Integer>(){
	public int compare(Integer o1, Integer o2){
		return Integer.compare(o1,o2);
	}
};
int compare1 = com1.compare(12,21);
System.out.println(compare1);//-1

Lambda表达式的写法

Comparator<Integer> com2 = (o1,02) -> Integer.compare(o1,o2);
int compare2 = com2.compare(21,11);
System.out.println(compare2);//1

格式

lambda形参列表 -> lambda体

• -> 的左边：Lambda形参列表，对应着要重写的接口中的抽象方法的形参列表。
• -> 的右边：Lambda体，对应着接口的实现类要重写的方法的方法体。

格式1

无参，无返回值：

public void test1(){
	Runnable r1 = new Runnable(){
		public void run(){
			System.out.println("你好");
		}
	};
	r1.run();

	//改造后的lambda形式
	Runnable r2 = () -> {
		System.out.println("你好");
	}
	r2.run();
} 

格式2

lambda需要一个参数，但是没有返回值

public void test2(){
	Consumer<String> con = new Consumer(){
		public void accept(String s){
			System.out.println(s);
		}
	};
	con.accept("你好");
	//改造后的lambda形式
	Consumer<String> con1 = (String s) ->{
		System.out.println(s);
	};
	con1.accept("hello")
}

格式3

数据类型可以忽略，因为可由编译器推断得出，称为"类型推断"

public void test3(){
	Consumer<String> con = new Consumer(){
		public void accept(String s){
			System.out.println(s);
		}
	};
	con.accept("你好");
	//改造后的lambda形式
	Consumer<String> con2 = (s) ->{
		System.out.println(s);
	};
	con2.accept("hello")
}

对于"类型推断"，多说一嘴，比如下面代码：

public void test3_1(){
	//①数组
	int[] arr = new int[]{1,2,3};
	//类型推断后
	int[] arr = {1,2,3};
	//②泛型
	HashMap<String,Integer> map = new HashMap<String,Integer>();
	//类型推断后
	HashMap<String,Integer> map = new HashMap<>();
}

格式4

lambda若只需要一个参数时，参数的小括号可以省略

public void test4(){
	Consumer<String> con = new Consumer(){
		public void accept(String s){
			System.out.println(s);
		}
	};
	con.accept("你好");
	//改造后的lambda形式
	Consumer<String> con2 = s ->{
		System.out.println(s);
	};
	con2.accept("hello")
}

格式5

lambda需要两个或两个以上的参数，多条执行语句，并且可以有返回值

public void test5(){
	Comparator<Integer> com1 = new Comparator(){
		public int compare(Integer o1,Integer o2){
			System.out.println(o1);
			System.out.println(o2);
			System.out.println(o2);
		}
	};
	System.out.println(com1.compare(12,21));
	//改造后的lambda形式
	Comparator<Integer> com2 = (o1,o2) ->{
		System.out.println(o1);
		System.out.println(o2);
		System.out.println(o2);
	};
	System.out.println(com2.compare(12,21));
}

格式6

当lambda体只有一条语句时，return与大括号若有，都可以省略

public void test6(){
	Comparator<Integer> com1 = (o1,o2) -> {
		return o1.compareTo(o2);
	};
	System.out.println(com1.compare(12,5));
	//改造后
	Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);
	System.out.println(com2.compare(12,16));
}

本质

• lambda表达式作为接口的实现类的对象
• lambda表达式是一个匿名函数
  万事万物皆对象，匿名函数时一个对象

函数式接口

定义

如果接口中只是声明有一个抽象方法，则此接口就称为函数式接口。因为只有给函数式接口提供实现类的对象时，我们才可以使用lambda表达式。

4个基本的函数式接口

在Java中，有四个常用的函数式接口，它们被称为四大核心函数式接口，分别是：

1. Function<T, R>：这个接口接受一个输入参数并产生一个结果。它的方法是apply()，用于将输入值映射到结果。例如，你可以使用它来将一个字符串转换为大写。

Function<String, String> toUpperCase = str -> str.toUpperCase();
String result = toUpperCase.apply("hello"); // "HELLO"

2. Consumer<T>：这个接口接受一个输入参数，但不返回任何结果。它的方法是accept()，用于操作或接受输入值。例如，你可以使用它来打印一个字符串。

Consumer<String> printString = str -> System.out.println(str);
printString.accept("Hello, World!"); // prints "Hello, World!"

3. Predicate<T>：这个接口接受一个输入参数并返回一个布尔值。它的方法是test()，用于测试输入值是否满足某个条件。例如，你可以使用它来检查一个数字是否是偶数。

Predicate<Integer> isEven = num -> num % 2 == 0;
boolean result = isEven.test(4); // true

4. Supplier<T>：这个接口不接受任何参数，但返回一个值。它的方法是get()，用于提供一个值。例如，你可以使用它来提供一个随机数生成器。

Supplier<Integer> randomNumberSupplier = () -> new Random().nextInt(100);
int randomNumber = randomNumberSupplier.get(); // a random number between 0 and 99

这些函数式接口在Java 8及以后的版本中非常有用，它们可以帮助你编写更简洁、更具表达力的代码。