JavaSE/21.Java基础之Lambda表达式

发表于 2020-12-19 | 更新于 2020-12-19

江头未是风波恶，别有人间行路难！

——辛弃疾《鹧鸪天》

JDK8新特性—Lambda表达式

1. 函数式编程思想概述

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。

1564054395492

1.1 冗余的Runnable代码

1.2 TreeSet的定制排序

1.3 为什么使用Lambda表达式呢？

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

2. Lambda表达式语法☆

Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ，该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：
左侧：指定了 Lambda 表达式需要的参数列表。无参数则留空，多个参数则用逗号分隔。

-> 是新引入的语法格式，代表指向动作。

右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即Lambda 表达式要执行的功能。
// Lambda表达式的标准格式为：
(参数类型 参数名称) ‐> { 代码语句 }

3.3 自定义函数式接口

MyFunction

/`
 * @Date 2020/11/14 11:38
 * @Version 10.21
 * @Author DuanChaojie
 */
@FunctionalInterface
public interface MyFunction<T> {
    public T getValue(T t);
}

MyFunctionTest

/`
 * @Date 2020/11/14 11:41
 * @Version 10.21
 * @Author DuanChaojie
 */
public class MyFunctionTest {
    public static void main(String[] args) {
        String haha = myFunctionTest((str) -> str.toUpperCase(), "haha");
        // HAHA
        System.out.println(haha);
    }

    public static String myFunctionTest(MyFunction<String> mf,String str){
        return mf.getValue(str);
    }
}

3.4 Java内置四大核心函数式接口

Supplier接口

java.util.function.Supplier<T> 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。

/**
 * @Date 2020/11/14 14:45
 * @Version 10.21
 * @Author DuanChaojie
 */
public class DemoSupplier {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Justweb";
        String result = getString(() -> str1 + str2);

        // result = HelloJustweb
        System.out.println("result = " + result);
    }

    private static String getString(Supplier<String> sup) {
        return sup.get();
    }
}

练习：求数组元素最大值:

使用 Supplier 接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值。提示：接口的泛型请使用java.lang.Integer 类。

/**
 * @Date 2020/11/14 14:48
 * @Version 10.21
 * @Author DuanChaojie
 */
public class ArrayMax {
    public static void main(String[] args) {
        int[] arr = {1,4,5,7,9,11,43,22};
        int result = getMax(() -> {
                int max = arr[0];
                for (int i = 0; i < arr.length; i++) {
                    if (arr[i] > max){
                        max = arr[i];
                    }
                };
                return max;
        });
        // 43
        System.out.println(result);
    }
    private static int getMax(Supplier<Integer> sup){
        return sup.get();
    }
}

Consumer接口

java.util.function.Consumer<T> 接口则正好相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型参数决定。

Consumer 接口中包含抽象方法void accept(T t) ，意为消费一个指定泛型的数据。基本使用如：

/**
 * @Date 2020/11/14 14:57
 * @Version 10.21
 * @Author DuanChaojie
 */
public class ConsumerDemo {
    public static void main(String[] args) {
        //consumerString(s -> System.out.println(s));
        consumerString(System.out::println);
    }

    private static void consumerString(Consumer<String> consumer){
        consumer.accept("Hello");
    }
}

Consumer接口默认方法andThen

如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费一个数据的时候，首先做一个操作，然后再做一个操作，实现组合。而这个方法就是Consumer 接口中的default方法 andThen 。下面是JDK8 Consumer类的源代码：

@FunctionalInterface
public interface Consumer<T> {
    
    void accept(T t);

     default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> {
            accept(t);
            after.accept(t);
        };
    }
}

java.util.Objects 的 requireNonNull 静态方法将会在参数为null时主动抛出NullPointerException 异常。这省去了重复编写if语句和抛出空指针异常的麻烦。

要想实现组合，需要两个或多个Lambda表达式即可，而 andThen 的语义正是“一步接一步”操作。例如两个步骤组合的情况：

/**
 * @Date 2020/11/14 15:06
 * @Version 10.21
 * @Author DuanChaojie
 */
public class ConsumerAndThen {
    public static void main(String[] args) {
        consumerString(
                s -> System.out.println(s.toUpperCase()),
                s -> System.out.println(s.toLowerCase()));
    }

    private static void consumerString(Consumer<String> one, Consumer<String> two) {
        one.andThen(two).accept("Hello");
    }
}

运行结果将会首先打印完全大写的HELLO，然后打印完全小写的hello。当然，通过链式写法可以实现更多步骤的组合。

练习：格式化打印信息

下面的字符串数组当中存有多条信息，请按照格式“ 姓名：XX 性别：XX”的格式将信息打印出来。要求将打印姓名的动作作为第一个 Consumer 接口的Lambda实例，将打印性别的动作作为第二个 Consumer 接口的Lambda实例，将两个 Consumer 接口按照顺序“拼接”到一起。

/**
 * @Date 2020/11/14 15:13
 * @Version 10.21
 * @Author DuanChaojie
 */
public class DemoConsumer {
    public static void main(String[] args) {
        String[] array = {"迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男"};
        printInfo(
                s -> System.out.println("姓名：" + s.split(",")[0]),
                s -> System.out.println("性别：" + s.split(",")[1]),
                array
        );
    }

    private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) {
        for (String info : array) {
            one.andThen(two).accept(info);
        }
    }
}

4. 方法引用和构造器引用

Employee

public class Employee {

    private int id;
    private String name;
    private int age;
    private double salary;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public Employee() {

    }

    public Employee(int id) {

        this.id = id;
    }

    public Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public Employee(int id, String name, int age, double salary) {

        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;

        Employee employee = (Employee) o;

        if (id != employee.id)
            return false;
        if (age != employee.age)
            return false;
        if (Double.compare(employee.salary, salary) != 0)
            return false;
        return name != null ? name.equals(employee.name) : employee.name == null;
    }

    @Override
    public int hashCode() {
        int result;
        long temp;
        result = id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        result = 31 * result + age;
        temp = Double.doubleToLongBits(salary);
        result = 31 * result + (int) (temp ^ (temp >>> 32));
        return result;
    }
}

4.1 方法引用

使用场景：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！

方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。

要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！

格式：使用操作符 “::” 将类(或对象) 与方法名分隔开来。如下三种主要使用情况：

对象:: 实例方法名

类:: 静态方法名

类:: 实例方法名

/**
 * 方法引用的使用
 * 1.使用场景：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
 * 2.方法引用，本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例，所以方法引用，也是函数式接口的实例。
 * 3.使用格式： 	类（或对象）:: 方法名
 * 4.具体分为如下三种情况：
 * 		1 对象:: 非静态方法
 * 		2 类:: 静态方法
 * 		3 类:: 非静态方法
 * 5.方法引用使用的要求：
 * 要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同(针对情况1和2)。
 */
public class MethodRefTest {

    // 情况一：对象 :: 实例方法
    // Consumer中的void accept(T t)
    // PrintStream中的void println(T t)
    @Test
    public void test1() {
        Consumer con1 = str -> System.out.println(str);
        con1.accept("北京");
        System.out.println("----------------------------");
        PrintStream ps = System.out;
        Consumer con2 = ps::println;
        con2.accept("beijing");
    }

    // Supplier中的T get()
    // Employee中的String getName()
    @Test
    public void test2() {
        Employee emp = new Employee(1001, "Tom", 23, 5600);
        Supplier<String> sup1 = () -> emp.getName();
        System.out.println(sup1.get());
        System.out.println("----------------------------");
        Supplier<String> sup2 = emp::getName;
        System.out.println(sup2.get());


    }

    // 情况二：类 :: 静态方法
    //Comparator中的int compare(T t1,T t2)
    //Integer中的int compare(T t1,T t2)
    @Test
    public void test3() {
        Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
        System.out.println(com1.compare(12, 21));//-1

        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(12, 3));//1
    }

    //Function中的R apply(T t)
    //Math中的Long round(Double d)
    @Test
    public void test4() {
        Function<Double, Long> func = new Function<Double, Long>() {
            @Override
            public Long apply(Double d) {
                return Math.round(d);
            }
        };
        System.out.println("---------------------------");
        Function<Double, Long> func1 = d -> Math.round(d);
        System.out.println(func1.apply(12.3));//12
        System.out.println("---------------------------");
        Function<Double, Long> func2 = Math::round;
        System.out.println(func2.apply(12.6));//13

    }

    // 情况三：类 :: 实例方法
    // Comparator中的int comapre(T t1,T t2)
    // String中的int t1.compareTo(t2)
    @Test
    public void test5() {
        Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
        System.out.println(com1.compare("abc", "abd"));//-1
        System.out.println("------------------------------");
        Comparator<String> com2 = String::compareTo;
        System.out.println(com2.compare("abc", "abm"));//-9
    }

    //BiPredicate中的boolean test(T t1, T t2);
    //String中的boolean t1.equals(t2)
    @Test
    public void test6() {
        BiPredicate<String, String> pre1 = (s1, s2) -> s1.equals(s2);
        System.out.println(pre1.test("abc", "abc"));
        System.out.println("--------------------------");
        BiPredicate<String, String> pre2 = String::equals;
        System.out.println(pre2.test("abc", "abc"));

    }

    // Function中的R apply(T t)
    // Employee中的String getName();
    @Test
    public void test7() {
        Employee employee = new Employee(1001, "Jerry", 23, 22222);
        Function<Employee, String> func1 = (e) -> e.getName();
        System.out.println(func1.apply(employee));
        System.out.println("------------------------------");
        Function<Employee, String> func2 = Employee::getName;
        System.out.println(func2.apply(employee));
    }

}

4.2 构造器引用

构造器引用：

格式： ClassName::new

与函数式接口相结合，自动与函数式接口中方法兼容。

可以把构造器引用赋值给定义的方法，要求构造器参数列表要与接口中抽象方法的参数列表一致！且方法的返回值即为构造器对应类的对象。

数组引用：

格式： type[] :: new

/**
 * 一、构造器引用
 * 		和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。
 * 		抽象方法的返回值类型即为构造器所属的类的类型。
 * 二、数组引用
 */
public class ConstructorRefTest {
    //构造器引用
    //Supplier中的T get()
    @Test
    public void test1() {
        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };

        Supplier<Employee> sup1 = () -> new Employee();

        // Employee{id=0, name='null', age=0, salary=0.0}
        Supplier<Employee> sup2 = Employee::new;
        System.out.println(sup2.get());


    }

    //Function中的R apply(T t)
    @Test
    public void test2() {
        Function<Integer, Employee> func1 = id -> new Employee(id);
        Employee employee = func1.apply(1001);
        System.out.println("--------------------------------");
        Function<Integer, Employee> func2 = Employee::new;
        System.out.println(func2.apply(1002));
    }

    //BiFunction中的R apply(T t,U u)
    @Test
    public void test3() {
        BiFunction<Integer, String, Employee> func1 = (id, name) -> new Employee(id, name);
        System.out.println(func1.apply(1001, "tom"));
        System.out.println("------------------------------------");
        BiFunction<Integer, String, Employee> func2 = Employee::new;
        System.out.println(func2.apply(1002, "Jerry"));

    }

    //数组引用
    //Function中的R apply(T t)
    @Test
    public void test4() {
        Function<Integer, String[]> func1 = (length) -> new String[length];
        String[] strs = func1.apply(5);
        System.out.println(Arrays.toString(strs));
        Function<Integer, String[]> func2 = String[]::new;
        String[] strs2 = func2.apply(3);

        System.out.println(Arrays.toString(strs2));

    }
}

☆

本文作者: DuanChaojie

本文链接: http://www.itbuild.cn/2020/12/19/JavaSE/21.Java%E5%9F%BA%E7%A1%80%E4%B9%8BLambda%E8%A1%A8%E8%BE%BE%E5%BC%8F/