Lambda 表达式

Lambda 表达式

一、函数式接口

函数式接口主要指只包含一个抽象方法的接口，如：java.lang.Runnable、java.util.Comparator 接口等。

Java8 提供 @FunctionalInterface 注解来定义函数式接口，若定义的接口不符合函数式的规范便会报错。

Java8 中增加了 java.util.function 包，该包包含了常用的函数式接口，具体如下：

接口名称	方法声明	功能介绍
Consumer	void accept(T t)	根据指定的参数执行操作
Supplier	T get()	得到一个返回值
Function<T,R>	R apply(T t)	根据指定的参数执行操作并返回
Predicate	boolean test(T t)	判断指定的参数是否满足条件

//首先创建一个Student类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person implements Comparable<Person>{
    private String name;
    private int age;
}

public class FunctionTest {
	public static void main(String[] args) {
        Person person = new Person("zhangfei", 35);      
        //匿名内部类的方式
        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                return person.getName();
            }
        };
        System.out.println(supplier.get()); // zhangfei
        //使用匿名内部类的方式
        Function<String, Integer> function = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s);
            }
        };
        System.out.println(function.apply("12345")); // 12345
    }
}

二、Lambda 表达式

1、简介

​ Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。Lambda 表达式是实例化函数式接口的重要方式。

2、语法格式

(参数列表) -> { 方法体; }

其中 ()、参数类型、{} 以及 return 关键字可以省略。-> 为 Lambda 运算符，读作（goes to）。省略的情况如下：

• () ：一个参数可以省略，无参数或多个参数不可以省略。
• 参数类型：不需要声明参数类型，编译器可以统一识别。
• {} ：和 if 一样，只有方法体只有一行语句，可以省略大括号。
• return 关键字：如果方法体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

//上述两个匿部类的方式改为Lambda表达式的方式为：
Supplier<String> supplier = () -> person.getName();

Function<String, Integer> function = s -> Integer.parseInt(s);

可以很明显的看出 Lambda 表达式的简洁明了，再看下面例子：

//匿名内部类的方式
Comparator<Integer> comparator1 = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1.compareTo(o2);
    }
};
System.out.println(comparator1.compare(10, 20)); // -1

//使用Lambda表达式
Comparator<Integer> comparator2 = (o1, o2) -> o1.compareTo(o2);
System.out.println(comparator2.compare(10, 20)); // -1

//匿名内部类的方式
Supplier<Person> supplier1 = new Supplier<Person>() {
    @Override
    public Person get() {
        return new Person();
    }
};
System.out.println(supplier1.get()); // null 0

//使用Lambda表达式
Supplier<Person> supplier2 = () -> new Person();
System.out.println(supplier2.get()); // null 0

也可以使用 Lambda 表达式创建一个线程：

System.out.println(Thread.currentThread().getName() + " 开始了");
new Thread(() -> {
    for (int i = 0; i < 10; i++) {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + i);
    }
}, "Lambda Thread ").start();
System.out.println(Thread.currentThread().getName() + " 结束了");

三、方法引用

​ 方法引用主要指通过方法的名字来指向一个方法而不需要为方法引用提供方法体（即方法本身有方法体），该方法的调用交给函数式接口执行。方法引用是在特定场景下 Lambda 表达式的一种简化表示，可以进一步简化代码的编写使代码更加紧凑简洁，从而减少冗余代码。

​ 方法引用在 MyBatis-Plus 的条件构造器中以及集合的操作中用得非常多！

​ 方法引用使用一对冒号 :: 将类或对象 与 方法名进行连接，通常使用方式如下：

• 对象的非静态方法引用 ObjectName :: MethodName
• 类的静态方法引用 ClassName :: StaticMethodName
• 类的非静态方法引用 ClassName :: MethodName
• 构造器的引用 ClassName :: new
• 数组的引用 TypeName[] :: new

下面是几段示例代码：

//使用Lambda表达式
Supplier<String> supplier1 = () -> person.getName();
//使用方法引用的方式
Supplier<String> supplier2 = person::getName;

//使用Lambda表达式
Function<String, Integer> function1 = s -> Integer.parseInt(s);
//使用方法引用的方式
Function<String, Integer> function2 = Integer::parseInt;

//使用Lambda表达式
Comparator<Integer> comparator1 = (o1, o2) -> o1.compareTo(o2);
System.out.println(comparator1.compare(10, 20)); // -1
//使用方法引用的方式
Comparator<Integer> comparator2 = Integer::compareTo;
System.out.println(comparator2.compare(10, 20)); // -1

//使用Lambda表达式
Supplier<Person> supplier1 = () -> new Person();
Function<Integer, Person[]> function1 = integer -> new Person[integer];
//使用方法引用的方式
Supplier<Person> supplier2 = Person::new;
Function<Integer, Person[]> function2 = Person[]::new;

这里放一条以前总结 MyBatis-Plus 的条件构造器的示例代码：

LambdaQueryWrapper<Student> queryWrapper = new LambdaQueryWrapper<>();
Student student = Student.builder().id(7).name("胡亥").age(23).gender("m").build();
queryWrapper.lt(Student::getAge, student.getAge()).orderByDesc(Student::getId);
List<Student> students = studentMapper.selectList(queryWrapper);
students.forEach(System.out::println);