第 15 章 Java8 新特性 - 《JavaSE 基础知识》

Java 8 新特性简介
Lambda 表达式
Stream API
- Stream 的实例化
- Stream 的中间操作

Java 8 新特性简介

Lambda 表达式

1、举例： (o1,o2) -> Integer.compare(o1,o2);

2、格式：
-> ：lambda操作符或箭头操作符
->左边：lambda形参列表（其实就是接口中的抽象方法的形参列表）
->右边：lambda体（其实就是重写的抽象方法的方法体）

3、Lambda表达式的使用：（分为6种情况介绍）

->左边：
- lambda形参列表的参数类型可以省略（类型推断）
- 如果lambda形参列表只有一个参数，其一对()也可以省略
->右边：
- lambda体应该使用一对{}包裹；
- 如果lambda体只有一条执行语句（可能是return语句），省略这一对{}和return关键字

4、Lambda表达式的本质：作为函数式接口的实例。
如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。
之前用匿名实现类表示的现在都可以用Lambda表达式来写。

【示例代码】

public class LambdaTest {
    //语法格式一：无参，无返回值
    @Test
    public void test1() {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();
        System.out.println("**************");
        Runnable r2 = () -> System.out.println("我爱北京故宫");
        r2.run();
    }
    //语法格式二：Lambda 需要一个参数，但是没有返回值。
    //语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
    //语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
    @Test
    public void test2() {
        Consumer<String> consumer1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer1.accept("谎言和誓言的区别是什么呢？");
        System.out.println("*******************************");
//        Consumer<String> consumer2 = (String s) -> {
//            System.out.println(s);
//        };
//        Consumer<String> consumer2 = (s) -> {
//            System.out.println(s);
//        };
        Consumer<String> consumer2 = s -> {
            System.out.println(s);
        };
        consumer2.accept("一个是听的人当真了，一个是说的人当真了");
    }
    //语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值。
    //语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略。
    @Test
    public void test3() {
        Comparator<Integer> comp1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        System.out.println(comp1.compare(12, 21));//-1
        System.out.println("*********");
//        Comparator<Integer> comp2 = (o1, o2) -> {
//            return o1.compareTo(o2);
//        };
        Comparator<Integer> comp2 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(comp2.compare(21, 12));//1
    }
}

Java 内置的 4 大核心函数式接口

方法引用

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

2、方法引用本质上就是Lambda表达式，也就是函数式接口的实例。

3、使用格式： 类(或对象) :: 方法名

4、具体分为如下的三种情况：

对象 :: 非静态方法
类 :: 静态方法
类 :: 非静态方法

5、方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型，与方法引用的方法的形参列表和返回值类型相同！（针对于情况1和情况2）

【示例代码】

public class MethodRefTest {
    // 情况一：对象 :: 实例方法
    //Consumer中的void accept(T t)
    //PrintStream中的void println(T t)
    @Test
    public void test1() {
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("北京");
        System.out.println("*******************");
        PrintStream ps = ;
        Consumer<String> con2 = System.out :: println;
        con2.accept("beijing");
    }
    // 情况二：类 :: 静态方法
    //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));
        System.out.println("*******************");
        Comparator<Integer> com2 = Integer :: compare;
        System.out.println(com2.compare(12,3));
    }
    // 情况三：类 :: 实例方法  (有难度)
    // 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"));
        System.out.println("*******************");
        Comparator<String> com2 = String :: compareTo;
        System.out.println(com2.compare("abd","abm"));
    }
}

构造器引用与数组引用

构造器引用和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型。
把数组看做是一个特殊的类，则写法与构造器引用一致。

【示例代码】

public class ConstructorRefTest {
    //构造器引用
    //Supplier中的T get()
    //Employee的空参构造器：Employee()
    @Test
    public void test1(){
        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        System.out.println("*******************");
        Supplier<Employee>  sup1 = () -> new Employee();
        System.out.println(sup1.get());
        System.out.println("*******************");
        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(employee);
        System.out.println("*******************");
        Function<Integer,Employee> func2 = Employee :: new;
        Employee employee1 = func2.apply(1002);
        System.out.println(employee1);
    }
    //数组引用
    //Function中的R apply(T t)
    @Test
    public void test4(){
        Function<Integer,String[]> func1 = length -> new String[length];
        String[] arr1 = func1.apply(5);
        System.out.println(Arrays.toString(arr1));
        System.out.println("*******************");
        Function<Integer,String[]> func2 = String[] :: new;
        String[] arr2 = func2.apply(10);
        System.out.println(Arrays.toString(arr2));
    }
}

Stream API

Stream 的实例化

【示例代码】

public class StreamAPITest {
    //创建 Stream方式一：通过集合
    @Test
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();
//        default Stream<E> stream() : 返回一个顺序流
        Stream<Employee> stream = employees.stream();
//        default Stream<E> parallelStream() : 返回一个并行流
        Stream<Employee> parallelStream = employees.parallelStream();
    }
    //创建 Stream方式二：通过数组
    @Test
    public void test2(){
        int[] arr = new int[]{1,2,3,4,5,6};
        //调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流
        IntStream stream = Arrays.stream(arr);
        Employee e1 = new Employee(1001,"Tom");
        Employee e2 = new Employee(1002,"Jerry");
        Employee[] arr1 = new Employee[]{e1,e2};
        Stream<Employee> stream1 = Arrays.stream(arr1);
    }
    //创建 Stream方式三：通过Stream的of()
    @Test
    public void test3(){
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
    }
    //创建 Stream方式四：创建无限流
    @Test
    public void test4(){
//      迭代
//      public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //遍历前10个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
//      生成
//      public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }
}

Stream 的中间操作

【示例代码】