Java：Java8新特性

1. Lambda表达式

1.1 Lambda表达式的好处

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）

使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升

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

1.2 Lambda表达式举例

//导入的包有;import org.junit.Test;import java.util.Comparator;

public class LambdaTest1 {
    @Test
    public void test1(){
        Runnable r1 = new Runnable(){
            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();

        //Lambad表达式写法
        Runnable r2 = () -> System.out.println("我爱北京天安门");
        r2.run();
    }
    @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);

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

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

1.3 Lambda表达式的使用

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

格式：

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

语法格式：

1. 语法格式一：无参，无返回值

   

2. 语法格式二：Lambda需要一个参数，但是没有返回值

   

3. 语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

   

4. 语法格式四：Lambda若只需要一个参数时，参数的小括号可以省略

   

5. 语法格式五：Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值

   

6. 语法格式六：当Lambda体只有一条语句时，return与大括号若有，都可以省略

   

总的来说，语法格式为：

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

//导入的包有：import org.junit.Test;import java.util.Comparator;import java.util.function.Consumer;

public class LambdaTest2 {
    @Test
    public void test1(){
        //语法格式一：无参，无返回值
        Runnable r1 = new Runnable(){
            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();

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

        //Lambad表达式写法
        Runnable r2 = () -> {
            System.out.println("我爱北京天安门");
        };
        r2.run();
    }
    @Test
    public void test2(){
        //语法格式二：Lambda需要一个参数，但是没有返回值
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("今天是个好日子");

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

        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("今天是个好日子");
    }
    @Test
    public void test3(){
        //语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("今天是个好日子");

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

        Consumer<String> con2 = (s) -> {
            System.out.println(s);
        };
        con2.accept("今天是个好日子");
    }
    @Test
    public void test4(){
        //语法格式四：Lambda若只需要一个参数时，参数的小括号可以省略
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("今天是个好日子");

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

        Consumer<String> con2 = s -> {
            System.out.println(s);
        };
        con2.accept("今天是个好日子");
    }
    @Test
    public void test5(){
        //语法格式五：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("*******************");

        Comparator<Integer> com2 = (o1,o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
    }
    @Test
    public void test6(){
        //语法格式六：当Lambda体只有一条语句时，return与大括号若有，都可以省略
        Comparator<Integer> com1 = (o1,o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };

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

        Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);
    }
}

2. 函数式(Functional)接口

• 只包含一个抽象方法的接口，称为函数式接口
• 你可以通过 Lambda 表达式来创建该接口的对象
• 我们可以在一个接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口
• 以前用匿名实现类表示的现在都可以用Lambda表达式来写
• 在java.util.function包下定义了Java 8 的丰富的函数式接口

3. 方法引用与构造器引用

3.1 方法引用

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

2. 方法引用本质：其本质为Lambda表达式，而Lambda表达式是为函数式接口的实例，所以方法引用，也是函数式接口的实例

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

4. 具体使用情况：

   • 对象 :: 非静态方法(实例方法)

     

   • 类 :: 静态方法

     

   • 类 :: 非静态方法

     

5. 使用要求：要求接口中抽象方法的形参列表和返回值类型，与方法引用的方法的形参列表和返回值类型相同，但当类调用非静态方法时，可以不相同

3.2 构造器引用与数组引用

构造器引用

和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属类的类型

数组引用

可以把数组看做是一个特殊的类，则写法与构造器引用一致

4. 强大的Stream API

4.1 Stream API概述

什么是Stream API

• Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中
• Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作
• 使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询
• Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算
• 集合讲的是数据，Stream讲的是计算

Stream的操作步骤

1. 创建Stream：一个数据源（如：集合、数组），获取一个流
2. 中间操作：一个中间操作链，对数据源的数据进行处理
3. 终止操作(终端操作) ：一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

注意事项

• Stream 自己不会存储元素
• Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream
• Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行

4.2 Stream的实例化

Stream的实例化有四种方式：

1. 创建Stream方式一：通过集合
2. 创建Stream方式二：通过数组
3. 创建Stream方式三：通过Stream的of()
4. 创建Stream方式四：创建无限流（不常使用）

//导入的包有:import org.junit.Test;import java.util.Arrays;import java.util.List;import java.util.stream.IntStream;import java.util.stream.Stream;

public class StreamTest {
    //创建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};
        //调用Array类的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};
        //常见的数组可以，自定义的数组arr1也行
        Stream<Employee> stream1 = Arrays.stream(arr1);
    }

    //创建Stream方式三：通过Stream的of()
    @Test
    public void test3(){
        Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
    }
}

4.3 Stream的中间操作

1. 筛选与切片

   

   //筛选与切片
       @Test
       public void test1(){
           List<Employee> list = EmployeeData.getEmployees();
           //filter(Predicate p):接收Lambda，从流中排除某些元素
           Stream<Employee> stream = list.stream();
           //查询员工表中薪资大于7000的员工信息
           stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
   
           //limit(n):截断流，使其元素不超过给定数量
           list.stream().limit(3).forEach(System.out::println);
   
           //skip(n):跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流
           list.stream().skip(3).forEach(System.out::println);
   
           //distinct():筛选，通过流所生成元素的hashCode()和equals()去除重复元素
           list.stream().distinct().forEach(System.out::println);
       }
   

2. 映射

   

   //映射
       @Test
       public void test2(){
           //接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
           List<String> list = Arrays.asList("aa","bb","cc","dd");
           list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
       }
   

3. 排序

   

   //排序
       @Test
       public void test3(){
           //sorted():自然排序
           List<Integer> list = Arrays.asList(12,45,-8,2,56,34);
           list.stream().sorted().forEach(System.out::println);
           //使用自然排序的条件是：所指定泛型要实现Comparable接口
   
           //sorted(Comparator com):定制排序
           List<Employee> employees = EmployeeData.getEmployees();
           employees.stream().sorted((e1,e2) -> Integer.compare(e1.getAge(),e2.getAge()))
                   .forEach(System.out::println);
       }
   

4.4 Stream的终止操作

1. 匹配与查找

   

   

   //匹配与查找
       @Test
       public void test1(){
           List<Employee> employees = EmployeeData.getEmployees();
           //allMatch(Predicate p):检查是否匹配所有元素：所有员工年龄是否大于18
           boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
           System.out.println(allMatch);
   
           //anyMatch(Predicate p):检查是否至少匹配一个元素：是否存在员工工资大于1000
           boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 1000);
           System.out.println(anyMatch);
   
           //noneMatch(Predicate p):检查是否没有匹配所有元素：是否存在员工姓“雷”
           boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
           System.out.println(noneMatch);
   
           //findFirst():返回第一个元素
           Optional<Employee> employee = employees.stream().findFirst();
           System.out.println(employee);
   
           //findAny():返回当前流中的任意元素
           Optional<Employee> employee1 = employees.stream().findAny();
           System.out.println(employee1);
   
           //count():返回流中元素总个数
           long count = employees.stream().count();
           System.out.println(count);
   
           //max(Comparator c):返回流中最大值:返回最高的工资
           Optional<Double> maxSalary = employees.stream().map(e -> e.getSalary()).max(Double::compare);
           System.out.println(maxSalary);
   
           //min(Comparator c):返回流中最小值:返回最低的工资
           Optional<Employee> minSalary = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
           System.out.println(minSalary);
   
           //forEach(Consumer c):内部迭代
           // 使用 Collection 接口需要用户去做迭代，称为外部迭代
           // 相反，Stream API 使用内部迭代——它帮你把迭代做了
           employees.stream().forEach(System.out::println);
       }
   

2. 归约

   

   //规约
       @Test
       public void test2(){
           //reduce(T iden, BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 T
           //练习：计算1-10的自然数的和
           List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
           Integer sum = list.stream().reduce(0, Integer::sum);
           System.out.println(sum);
   
           //reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
           //练习：计算公司所有员工工资的总和
           List<Employee> employees = EmployeeData.getEmployees();
           Stream<Double> salaryStream = employees.stream().map(Employee::getSalary);
           Optional<Double> sumMoney = salaryStream.reduce((d1, d2) -> d1 + d2);
           System.out.println(sumMoney);
       }
   

3. 收集

   

   //收集
       @Test
    public void test3(){
           //collect(Collector c)将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
           //练习：查找工资大于6000的员工，结果返回为一个List或Set
   
           //结果返回为一个List
           List<Employee> employees = EmployeeData.getEmployees();
           List<Employee> list = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
           list.forEach(System.out::println);
   
           //结果返回为一个Set
           Set<Employee> set = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
           list.forEach(System.out::println);
       }
   

5. Optional类

Optional< T > 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。

原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常

Optional提供很多有用的方法，这样我们就不用显式进行空值检测：

1. 创建Optional类对象的方法：
   • Optional.of(T t)：创建一个 Optional 实例，t必须非空
   • Optional.empty()：创建一个空的 Optional 实例
   • Optional.ofNullable(T t)：t可以为null
2. 判断Optional容器中是否包含对象：
   • boolean isPresent()：判断是否包含对象
3. 获取Optional容器的对象：
   • T get(): 如果调用对象包含值，返回该值，否则抛异常
   • T orElse(T other) **：**如果有值则将其返回，否则返回指定的other对象

举例说明Optional类：