Java8 的新特性

Java8 的新特性

Lambda表达式

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

@Test
public void test2(){
    Comparator<Integer> com1 = new Comparator<Integer>(){
        @Override
        public int compare(Integer o1, Integer o2) {
            return Integer.compare(o1, o2);
        }
    };

    int compare1 = com1.compare(12,21);
    System.out.println(compare1);

    System.out.println("***********");

    //lambda表达式
    Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1,o2);
    int compare2 = com2.compare(32,21);
    System.out.println(compare2);

    System.out.println("***********");

    //方法引用
    Comparator<Integer> com3 = Integer::compare;
    int compare3 = com2.compare(32,21);
    System.out.println(compare3);
}

语法

@Test
public void test3(){
    //语法格式：无参，无返回值
    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("测试");
        }
    };

    r1.run();

    System.out.println("*****************");

    Runnable r2 = () -> System.out.println("测试2");

    r2.run();

    //语法格式二：Lambda表达式有参数，无返回值
    Consumer<String> con = new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    con.accept("123");

    System.out.println("***********************");

    Consumer<String> con1 = (String s) -> {
        System.out.println("s");
    };

    con.accept("321");

    //语法格式三：数据类型可以省略，因为可由编译器推断得出，称为"类型推断"
    Consumer<String> co1 = (String s) -> {
        System.out.println("s");
    };
    co1.accept("321");

    System.out.println("***********************");

    Consumer<String> co2 = (s) -> {
        System.out.println("s");
    };
    co2.accept("321");

    //类型推断还有以下几例：
    //ArrayList<String> list = new ArrayList<>();

    //int[] arr = {1,2,3};

    //语法格式四：Lambda若只需要一个参数时，参数的小括号可以省略
    Consumer<String> co3 = s -> {
        System.out.println("s");
    };
    co3.accept("321");

    //语法格式五：Lambda需要两个或者以上的参数，多条执行语句，并且可以有返回值
    Comparator<Integer> com1 = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        }
    };
    System.out.println(com1.compare(12,21));

    System.out.println("******************");

    Comparator<Integer> com2 = (o1,o2) -> {
        System.out.println(o1);
        System.out.println(o2);
        return o1.compareTo(o2);
    };

    System.out.println(com2.compare(6,21));

    //语法格式六：当Lambda体只有一条语句时，return 与大括号若有，都可以省略
    Comparator<Integer> com3 = (o1,o2) -> o1.compareTo(o2);

    System.out.println(com3.compare(12,21));

}

本质

Lambda表达式的本质：作为函数式接口的实例

总结

-> 左边：Lambda形参列表的参数类型可以省略（类型推断）如果Lambda形参列表只有一个参数，其一对（）也可以省略

-> 右边：Lambda体应该使用一对{}包裹；如果Lambda体只有一条执行语句（可能是return语句），省略这一对{}和return关键字

函数式接口

定义

如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口

可以通过Lambda表达式来创建该接口的对象

可以在一个接口上使用@FunctionalInterface注解，这样做可以检验它是否是一个函数式接口。同时javadoc也会包含一条声明，说明这个接口是一个函数式接口

在java.util.function包下定义了Java 8的丰富的函数式接口

理解

java不但可以支持面向对象编程还可以支持面向函数编程

内置函数式接口

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-crK6qgDj-1629432875205)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210803160540524.png)]

方法引用

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

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

要求

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

格式

类（或对象）：：方法名

如下三种主要使用情况：

对象::实例方法名

类::静态方法名

类::实例方法名

本质

本质上就是Lambda表达式，也是函数式接口的实例

@Test
public void test4(){
    Consumer<String> con1 = str -> System.out.println(str);
    con1.accept("北京");

    System.out.println("****************");

    PrintStream ps = System.out;
    Consumer<String> con2 = ps::println;
    con2.accept("beijing");
}

Stream API

Stream API 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

Stream和Collection 集合的区别：Collection 是一种静态的内存数据结构；而Stream 是有关计算的。 前者是主要面向内存，存储在内存中，后者主要是面向CPU，通过CPU 实现计算

定义

Stream 是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

“集合讲的是数据，Stream讲的是计算”

注意：

1、Stream 自己不会存储元素

2、 Stream 不会改变源对象，相反，他们会返回一个持有结构的新Stream

3、 Stream 操作是延迟执行的，这意味着他们会等到需要结果的时候才执行。

操作步骤

1、创建Stream

一个数据源（如：集合、数组），获取一个流

2、中间操作

一个中间操作链，对数据源的数据进行处理

3、终止操作（终端操作）

一旦执行终止操作，就执行中间操作链，并产生结果，之后，不会再被使用

实例化

//创建 Stream 方式一：通过集合
@Test
public void test1(){
    List<Employee> employees = EmployeeData.getEmployees();
    
    // 返回一个顺序流
    Stream<Employee> stream = employees.stream();
    
    // 返回一个并行流
    Stream<Employee> parallelStream = employees.parallelStream();
}

//创建 Stream 方式二：通过数组
@Test
public void test2(){
    int[] arr = new int[]{1,2,3,4,5,6};
    //返回一个流
    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(){
    //迭代
    //遍历前10个偶数
    Stream.iterate(0,t -> t + 2).limit(10).forEach(System.out::println);

    //生成
    Stream.generate(Math::random).limit(10).forEach(System.out::println);

}

中间操作

1、筛选和切片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x7PTTUSl-1629432875211)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210803173913253.png)]

2、映射

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-074cwDn2-1629432875213)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210803173935805.png)]

3、排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cBncXgdU-1629432875216)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210803173955700.png)]

终止操作

1、匹配与查找

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4BLMhXYX-1629432875219)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210803174048978.png)]

2、归约

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-100Aq8KH-1629432875221)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210803174123117.png)]

3、收集

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OEVT4MLs-1629432875222)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210803174155810.png)]

Optional类

是一个容器类，它可以保存类型T的值，代表这个值存在，或者仅仅保存null，表示这个值不存在。原来用Null表示一个值不存在，现在Optional可以更好的表达这个概念，并且可以避免空指针异常

.(img-cBncXgdU-1629432875216)]

终止操作

1、匹配与查找

[外链图片转存中…(img-4BLMhXYX-1629432875219)]

2、归约

[外链图片转存中…(img-100Aq8KH-1629432875221)]

3、收集

[外链图片转存中…(img-OEVT4MLs-1629432875222)]

Optional类

是一个容器类，它可以保存类型T的值，代表这个值存在，或者仅仅保存null，表示这个值不存在。原来用Null表示一个值不存在，现在Optional可以更好的表达这个概念，并且可以避免空指针异常

Optional类的Javadoc描述如下：这是一个为null的容器对象。如果值存在则isPresent()方法会返回True，调用get()方法会返回该对象