【Java8 重要特性】Lambda 表达式

Lambda

Lambda是一个匿名函数，我们可以将Lambda表达式理解为一段可以传递的代码（将代码像数据一样传递）。使用它可以写出简洁、灵活的代码。作为一种更紧凑的代码风格，使 java 语言表达能力得到提升。

基本语法

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

函数式接口

函数式接口：只包含一个抽象方法的接口，并且可以使用 Lambda 表达式来创建该接口的对象。

• 函数式接口： 有且仅有一个抽象方法的接口
• Java 中的函数式编程体现就是 Lambda 表达式
• 所以函数式接口即可以适用于 Lambda 使用的接口

public static void main(String[] args) {//使用匿名函数new Thread(new Runnable(){@Overridepublic void run(){System.out.println("我是没有使用Lambda表达式：不简洁");}}).start();
}//使用Lambda表达式new Thread(() -> System.out.println("我是使用Lambda表达式：简洁、灵活")).start();
}

可以在任意函数式接口上使用 @FunctionalInterface 注解，来检测它是否是符合函数式接口。同时 javac 也会包含一条声明，说明这个接口是否符合函数式接口。

// 通过
@FunctionalInterface
public interface Lock {public abstract String lockUp(String str1,String str2);  //上锁// public abstract void openLock();  //开锁
}
// 报错
@FunctionalInterface
public interface Lock {public abstract String lockUp(String str1,String str2);  //上锁public abstract void openLock();  //开锁
}

注意：自定义函数式接口时，@FunctionalInterface是可选的，就算不写这个注解，只要保证满 足函数式接口定义的条件，也照样是函数式接口。

Lambda 规则规范

Lambda 表达式在 java 语言中引入了一种新的语法元素和操作。这种操作符号为 “->” ，Lambda 操作符或箭头操作符，它将 Lambda 表达式分割为两部分。

• 左边：指 Lambda 表达式的所有参数
• 右边：指 Lambda 体，即表示 Lambda 表达式需要执行的功能

Lambda表达式省略规则

1.Lambda的标准格式(参数类型1 参数名1, 参数类型2 参数名2) -> {...方法体的代码...return 返回值;}
2.在标准格式的基础上()中的参数类型可以直接省略，因为编译器可以推断得出，称为“类型推断”(参数名1, 参数名2) -> {...方法体的代码...return 返回值;}
3.如果{}总的语句只有一条语句，则{}可以省略、return关键字、以及最后的“;”都可以省略(参数名1, 参数名2) -> 结果
4.如果()里面只有一个参数，则()可以省略参数名 -> 结果

简化过程

只有基于函数式接口的匿名内部类才能被 Lambda 表达式简化。下面使用 Lambda 简化函数式接口，改写 Arrays 方法代码。

改写 Arrays.setAll()

setAll 用于对数组进行批量更新。其作用是根据给定的函数更新数组中的每个元素。

语法如下：

public static <T> void setAll(T[] array, IntFunction<? extends T> generator)

• array: 要更新的数组
• generator: 一个 IntFunction，根据数组的索引生成新的值

需求如下：把所有元素 * 0.8

public class LambdaTest {public static void main(String[] args) {double[] prices = {99.8, 128, 100};//1.先用匿名内部类写法Arrays.setAll(prices, new IntToDoubleFunction() {@Overridepublic double applyAsDouble(int value) {// value = 0  1  2return prices[value] * 0.8;}});//2.使用Lambda表达式标准写法Arrays.setAll(prices, (int value) -> {return prices[value] * 0.8;});//3.使用Lambda表达式简化格式1——省略参数类型Arrays.setAll(prices, (value) -> {return prices[value] * 0.8;});//4.使用Lambda表达式简化格式2——省略()Arrays.setAll(prices, value -> {return prices[value] * 0.8;});//5.使用Lambda表达式简化格式3——省略{}Arrays.setAll(prices, value -> prices[value] * 0.8 );System.out.println(Arrays.toString(prices));}
}

改写 Arrays.sort()

sort 方法用于对数组进行排序

语法如下：

public static <T> void sort(T[] a, Comparator<? super T> c)

• a: 要排序的对象数组
• c: 自定义的比较器（Comparator）

需求如下：对数组中的元素按照年龄升序排列

public class LambdaTest2 {public static void main(String[] args) {Student[] students = new Student[4];students[0] = new Student("张三", 169.5, 23);students[1] = new Student("李四", 163.8, 26);students[2] = new Student("王五", 163.8, 26);students[3] = new Student("赵六", 167.5, 24);//1.先用匿名内部类写法Arrays.sort(students, new Comparator<Student>() {@Overridepublic int compare(Student o1, Student o2) {return Double.compare(o1.getHeight(), o2.getHeight()); // 升序}});//2.使用Lambda表达式标准格式Arrays.sort(students, (Student o1, Student o2) -> {return Double.compare(o1.getHeight(), o2.getHeight()); // 升序});//3.使用Lambda表达式简化格式1——省略参数类型Arrays.sort(students, ( o1,  o2) -> {return Double.compare(o1.getHeight(), o2.getHeight()); // 升序});//4.使用Lambda表达式简化格式3——省略{}Arrays.sort(students, ( o1,  o2) -> Double.compare(o1.getHeight(), o2.getHeight()));System.out.println(Arrays.toString(students));}
}

forEach

forEach 是 Java 8 引入的一种简洁的方式，用于遍历集合中的每个元素。它是 Collection 接口和 Map 接口中的一个默认方法，支持函数式编程风格。forEach 方法可以与 Lambda 表达式或方法引用结合使用，简化了传统的迭代代码。

forEach 方法的定义如下：

void forEach(Consumer<? super T> action);

• Consumer: 函数式接口，表示接受一个输入参数并对其进行操作而没有返回结果
• T: 集合中元素的类型

循环 list 集合

List<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
list.forEach(s -> System.out.println(s));

循环 list 集合并输出对象信息

public class UserVo {private String userName;public String getUserName() {return userName;}public void setUserName(String userName) {this.userName = userName;}
}
List<UserVo> list = new ArrayList<UserVo>();
list.add(new UserVo());
list.add(new UserVo());
list.add(new UserVo());
list.forEach(s -> System.out.println(s.getUserName()));

循环 Map 集合

Map<String, UserVo> map = new HashMap<String, UserVo>();
map.put("A", new UserVo());
map.put("B", new UserVo());
map.put("C", new UserVo());

使用传统 forEach 循环

for (Map.Entry<String, UserVo> entry : map.entrySet()) {System.out.println(entry.getKey() + ":" + entry.getValue().getUserName());
}

使用 lambda 表达式

map.forEach(new BiConsumer<String, UserVo>() {@Overridepublic void accept(String k, UserVo v) {System.out.println(k + ":" + v.getUserName());}
});

简写

map.forEach((k,v) -> System.out.println(k + ":" + v.getUserName()));

方法引用和构造器引用

方法引用

当要传递给 Lambda 体的操作已经有实现方法，可以直接使用方法引用(实现抽象方法的列表，必须要和方法引用的方法参数列表一致)

方法引用使用操作符 :: 将方法名和类或者对象分割开来

有下列三种情况：

对象::实例方法
类::实例方法
类::静态方法

@FunctionalInterface
public interface Lock {public abstract void lockUp(String str);  //上锁
}
Lock lock = System.out::println;
lock.lockUp("测试......");

构造器引用

本质上构造器引用和方法引用相似，只是使用了一个 new 方法

使用说明：函数式接口参数列表和构造器参数列表要一致，该接口返回值类型也是构造器返回值类型

格式：ClassName :: new

@FunctionalInterface
public interface Lock {public abstract String lockUp(String str);  //上锁
}
// 非构造器引用
Lock lock1 = (s) -> new String(s);
// 构造器引用
Lock lock2 = String::new;