一篇文章轻松掌握Java8的新特性

港控/mmm° 2023-10-04 12:14 10阅读 0赞

## 概述 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 1]

## ① 接口内允许添加默认实现的方法 ##

Java 8 允许我们通过 `default` 关键字对接口中定义的抽象方法提供一个默认的实现。

示例：

/**
     * @author cVzhanshi
     * @create 2022-11-01 14:43
     */
    public interface TestDefaultMethods {
        
        int getArg(int a);
    	
        // 默认方法
        default double sqrt(double a){
        
            return Math.sqrt(a);
        }
    }

接口中定义了一个抽象方法`getArg`，还定义了一个带有默认实现的方法 `sqrt`。那么我们在实现接口的时候可以只实现`getArg`方法，而不必强制实现默认方法 `sqrt` ，可以直接调用默认方法 `sqrt` 。

示例：

/**
     * @author cVzhanshi
     * @create 2022-11-01 14:41
     */
    public class TestJava8 {
        
        public static void main(String[] args) {
        
            TestDefaultMethods testDefaultMethods = new TestDefaultMethods() {
        
                @Override
                public int getArg(int a) {
        
                    return a + 100;
                }
            };
            System.out.println(testDefaultMethods.getArg(100));   // 200
            System.out.println(testDefaultMethods.sqrt(100));     // 4.0
        }
    }

通过 default关键字这个新特性，可以非常方便地对之前的接口做拓展，而此接口的实现类不必做任何改动

## ② Lambda表达式 ##

### 2.1 Lambda表达式使用前后的对比 ###

//举例一：
    @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();
    }
    
    //举例二：
    @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 = com3.compare(32,21);
        System.out.println(compare3);
    }

### 2.2 Lambda表达式的基本语法 ###

*  1.举例： (o1,o2) -> Integer.compare(o1,o2);
 *  2.格式：
    
     *      -> :lambda操作符 或 箭头操作符
     *      ->左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表
     *      ->右边：lambda体 （其实就是重写的抽象方法的方法体

### 2.3 如何使用：分为六种情况 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 2]

### 2.4 总结六种情况 ###

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

### 2.5 Lambda 访问外部变量及接口默认方法 ###

#### 2.5.1 访问局部变量 ####

在 Lambda 表达式中，我们可以访问外部的 `final` 类型变

代码示例

// 转换器
    @FunctionalInterface
    interface Converter<F, T> {
        
        T convert(F from);
    }
    
    
    final int num = 1;
    Converter<Integer, String> stringConverter =
            (from) -> String.valueOf(from + num);
    
    stringConverter.convert(2);     // 3

**与匿名内部类不同的是，我们不必显式声明 `num` 变量为 `final` 类型**，下面这段代码同样有效：

int num = 1;
    Converter<Integer, String> stringConverter =
            (from) -> String.valueOf(from + num);
    
    stringConverter.convert(2);     // 3

但是 `num` 变量必须为隐式的 `final` 类型，何为隐式的 `final` 呢？就是说到编译期为止，`num` 对象是不能被改变的，如下面这段代码，就不能被编译通过：

int num = 1;
    Converter<Integer, String> stringConverter =
            (from) -> String.valueOf(from + num);
    num = 3;

在 lambda 表达式内部改变 `num` 值同样编译不通过，需要注意, 比如下面的示例代码：

int num = 1;
    Converter<Integer, String> converter = (from) -> {
        
    	String value = String.valueOf(from + num);
    	num = 3;
    	return value;
    };

#### 2.5.2 访问成员变量和静态变量 ####

与局部变量相比，在 Lambda 表达式中对成员变量和静态变量拥有读写权限

代码测试：

/**
     * @author cVzhanshi
     * @create 2022-11-01 15:10
     */
    @FunctionalInterface
    public interface Converter<F , T> {
        
        T convert(F from);
    }

// 静态变量
    static int outerStaticNum;
    // 成员变量
    int outerNum;
    
    void testScopes() {
        
        Converter<Integer, String> stringConverter1 = (from) -> {
        
            // 对成员变量赋值
            outerNum = 23;
            return String.valueOf(from + outerNum);
        };
    
        System.out.println(stringConverter1.convert(11));  // 34
        Converter<Integer, String> stringConverter2 = (from) -> {
        
            // 对静态变量赋值
            outerStaticNum = 72;
            return String.valueOf(from + outerStaticNum);
        };
        System.out.println(stringConverter2.convert(22));   //94
    }

#### 2.5.3 访问接口的默认方法 ####

代码示例：

@FunctionalInterface
    interface Formula {
        
    	// 计算
    	double calculate(int a);
    
    	// 求平方根
    	default double sqrt(int a) {
        
    		return Math.sqrt(a);
    	}
    }
    // 在接口中定义了一个带有默认实现的 sqrt 求平方根方法，在匿名内部类中我们可以很方便的访问此方法：
    Formula formula = new Formula() {
        
    	@Override
    	public double calculate(int a) {
        
    		return sqrt(a * 100);
    	}
    };

但是在 lambda 表达式中可不行，带有默认实现的接口方法，是**不能**在 lambda 表达式中访问的，下面这段代码将无法被编译通过。

Formula formula = (a) -> sqrt(a * 100);

带有默认实现的接口方法，是**不能**在 lambda 表达式中访问的

## ③ 函数式接口 ##

### 3.1 函数式接口的使用说明 ###

**所谓函数式接口（Functional Interface）就是只包含一个抽象方法的声明。**  
我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。  
Lambda表达式的本质：作为函数式接口的实例

> 注意：你可能会有疑问，Java 8 中不是允许通过 defualt 关键字来为接口添加默认方法吗？那它算不算抽象方法呢？答案是：不算。因此，你可以毫无顾忌的添加默认方法，它并不违反函数式接口（Functional Interface）的定义。

总结：只要接口中仅仅包含一个抽象方法，我们就可以将其改写为 Lambda 表达式。为了保证一个接口明确的被定义为一个函数式接口（Functional Interface），我们需要为该接口添加注解：`@FunctionalInterface`。这样，一旦你添加了第二个抽象方法，编译器会立刻抛出错误提示。

代码示例：

/**
     * @author cVzhanshi
     * @create 2022-11-01 15:10
     */
    @FunctionalInterface
    public interface Converter<F , T> {
        
        T convert(F from);
    }
    
    /**
     * @author cVzhanshi
     * @create 2022-11-01 14:41
     */
    public class TestJava8 {
        
        public static void main(String[] args) {
        
            Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
            Integer convert = converter.convert("123");
            System.out.println(convert);   // 123
        }
    }

**`@FunctionalInterface` 注解只是起到了一种约束，去掉也是没问题的**

### 3.2 基本的函数式接口 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 3]

#### 3.2.1 Predicate断言 ####

`Predicate` 是一个可以指定入参类型，并返回 boolean 值的函数式接口。它内部提供了一些带有默认实现的方法，可以 被用来组合一个复杂的逻辑判断（`and`, `or`, `negate`）：

@Test
    void testPredicate(){
        
        Predicate<String> predicate = (s) -> s.length() >= 5;
        System.out.println(predicate.test("aaa"));   // false
        System.out.println(predicate.test("bbbbb")); // true
    
        // negate取反
        System.out.println(predicate.negate().test("bbbbb"));
    
    
        Predicate<Boolean> nonNull = Objects::nonNull;
        Predicate<Boolean> isNull = Objects::isNull;
    
        Predicate<String> isEmpty = String::isEmpty;
        Predicate<String> isNotEmpty = isEmpty.negate();
    
    }

#### 3.2.2 Function ####

`Function` 函数式接口的作用是，我们可以为其提供一个原料，他给生产一个最终的产品。通过它提供的默认方法，组合,链行处理(`compose`, `andThen`)：

@Test
    void testFunction(){
        
        Function<String ,Integer> toInteger = Integer::valueOf;
        Integer apply = toInteger.apply("123");
        System.out.println(apply.getClass().getTypeName());  // java.lang.Integer
    
        Function<String ,String> backToString = toInteger.andThen(String::valueOf);
    
        System.out.println(backToString.apply("123").getClass().getTypeName());  //java.lang.String
    }

#### 3.2.3 Supplier 生产者 ####

`Supplier` 与 `Function` 不同，它不接受入参，直接为我们生产一个指定的结果，有点像生产者模式：

class Person {
        
        String firstName;
        String lastName;
    
        Person() {
        }
    
        Person(String firstName, String lastName) {
        
            this.firstName = firstName;
            this.lastName = lastName;
        }
    }
    
    @Test
    void testSupplier(){
        
        Supplier<Person> personSupplier = Person::new;
        personSupplier.get();   // new Person
    }

#### 3.2.4 Consumer 消费者 ####

对于 `Consumer`，我们需要提供入参，用来被消费

@Test
    void testConsumer(){
        
        Consumer<Person> greeter  = (p) -> System.out.println("Hello, " + p.getName());
        greeter.accept(new Person("aa",12));
    }

#### 3.2.5 Comparator ####

`Comparator` 在 Java 8 之前是使用比较普遍的。Java 8 中除了将其升级成了函数式接口，还为它拓展了一些默认方法：

Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
    
    Person p1 = new Person("John", "Doe");
    Person p2 = new Person("Alice", "Wonderland");
    
    comparator.compare(p1, p2);             // > 0
    comparator.reversed().compare(p1, p2);  // < 0

### 3.3 总结 ###

*  何时使用lambda表达式？  
    当需要对一个函数式接口实例化的时候，可以使用lambda表达式。
 *  何时使用给定的函数式接口？  
    如果我们开发中需要定义一个函数式接口，首先看看在已有的jdk提供的函数式接口是否提供了能满足需求的函数式接口。如果有，则直接调用即可，不需要自己再自定义了

## ④ 方法引用 ##

### 4.1 理解 ###

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

### 4.2 使用情境 ###

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

### 4.3 格式 ###

类(或对象) :: 方法名

分为如下的三种情况：

*  情况1 对象 :: 非静态方法
 *  情况2 类 :: 静态方法
 *  情况3 类 :: 非静态方法

### 4.4 要求 ###

> 要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同！（针对于情况1和情况2）  
> 当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数(或无参数)时：ClassName::methodName（针对于情况3）

### 4.5 使用建议 ###

如果给函数式接口提供实例，恰好满足方法引用的使用情境，大家就可以考虑使用方法引用给函数式接口提供实例。如果大家不熟悉方法引用，那么还可以使用lambda表达式。

### 4.6 代码举例 ###

// 情况一：对象 :: 实例方法
    //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 = System.out;
    	Consumer<String> 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));
    
    	System.out.println("*******************");
    
    	Comparator<Integer> com2 = Integer::compare;
    	System.out.println(com2.compare(12,3));
    
    }
    
    //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));
    
    	System.out.println("*******************");
    
    	Function<Double,Long> func2 = Math::round;
    	System.out.println(func2.apply(12.6));
    }
    
    // 情况：类 :: 实例方法  (难度)
    // 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"));
    }
    
    //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","abd"));
    }
    
    // Function中的R apply(T t)
    // Employee中的String getName();
    @Test
    public void test7() {
    	Employee employee = new Employee(1001, "Jerry", 23, 6000);
    
    
    	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));
    
    
    }

## ⑤ 构造器引用与数组引用 ##

### 5.1 构造器引用格式 ###

类名::new

### 5.2 构造器引用使用要求 ###

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

### 5.3 构造器引用举例 ###

//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);
    
       }
    
    //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,"Tom"));
    
       }

### 5.4 数组引用格式 ###

数组类型\[\] :: new

### 5.5 数组引用举例 ###

//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 ##

### 6.1 简介 ###

*  可以使用 `java.util.Stream` 对一个包含一个或多个元素的集合做各种操作。这些操作可能是 *中间操作* 亦或是 *终端操作*。 终端操作会返回一个结果，而中间操作会返回一个 `Stream` 流。
 *  需要注意的是，你只能对实现了 `java.util.Collection` 接口的类做流的操作。
    
    **`Map` 不支持 `Stream` 流**
 *  `Stream` 流支持同步执行，也支持并发执行。
 *  Stream关注的是对数据的运算，与CPU打交道集合关注的是数据的存储，与内存打交道
 *  java8提供了一套api，使用这套api可以对内存中的数据进行过滤、排序、映射、归约等操作。类似于sql对数据库中表的相关操作。

> **注意点**

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

> **Stream的使用流程**

1.  Stream的实例化
2.  一系列的中间操作（过滤、映射、…)
3.  终止操作

> **使用流程的注意点**

*  一个中间操作链，对数据源的数据进行处理
 *  一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

### 6.2 步骤一：Stream实例化 ###

实例化的方式

*  创建 Stream方式一：通过集合 —> employees.stream();
 *  创建 Stream方式二：通过数组 ----> Arrays.stream(arr);
 *  创建 Stream方式三：通过Stream的of() -----> Stream.of(1, 2, 3, 4, 5, 6);
 *  创建 Stream方式四：创建无限流

//创建 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);
    
    }

### 6.3 步骤二：中间操作 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 4]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 5]

//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);
    
            System.out.println();
    //        limit(n)——截断流，使其元素不超过给定数量。
            list.stream().limit(3).forEach(System.out::println);
            System.out.println();
    
    //        skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
            list.stream().skip(3).forEach(System.out::println);
    
            System.out.println();
    //        distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
    
            list.add(new Employee(1010,"刘强东",40,8000));
            list.add(new Employee(1010,"刘强东",41,8000));
            list.add(new Employee(1010,"刘强东",40,8000));
            list.add(new Employee(1010,"刘强东",40,8000));
            list.add(new Employee(1010,"刘强东",40,8000));
    
    //        System.out.println(list);
    
            list.stream().distinct().forEach(System.out::println);
        }
    
        //映射
        @Test
        public void test2(){
        
    //        map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。
            List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
            list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
    
    //        练习1：获取员工姓名长度大于3的员工的姓名。
            List<Employee> employees = EmployeeData.getEmployees();
            Stream<String> namesStream = employees.stream().map(Employee::getName);
            namesStream.filter(name -> name.length() > 3).forEach(System.out::println);
            System.out.println();
            //练习2：
            Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
            streamStream.forEach(s ->{
        
                s.forEach(System.out::println);
            });
            System.out.println();
    //        flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
            Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
            characterStream.forEach(System.out::println);
    
        }
    
        //将字符串中的多个字符构成的集合转换为对应的Stream的实例
        public static Stream<Character> fromStringToStream(String str){
        //aa
            ArrayList<Character> list = new ArrayList<>();
            for(Character c : str.toCharArray()){
        
                list.add(c);
            }
           return list.stream();
    
        }
    
    
    
        @Test
        public void test3(){
        
            ArrayList list1 = new ArrayList();
            list1.add(1);
            list1.add(2);
            list1.add(3);
    
            ArrayList list2 = new ArrayList();
            list2.add(4);
            list2.add(5);
            list2.add(6);
    
    //        list1.add(list2);
            list1.addAll(list2);
            System.out.println(list1);
    
        }
    
        //3-排序
        @Test
        public void test4(){
        
    //        sorted()——自然排序
            List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);
            list.stream().sorted().forEach(System.out::println);
            //抛异常，原因:Employee没有实现Comparable接口
    //        List<Employee> employees = EmployeeData.getEmployees();
    //        employees.stream().sorted().forEach(System.out::println);
    
    
    //        sorted(Comparator com)——定制排序
    
            List<Employee> employees = EmployeeData.getEmployees();
            employees.stream().sorted( (e1,e2) -> {
        
    
               int ageValue = Integer.compare(e1.getAge(),e2.getAge());
               if(ageValue != 0){
        
                   return ageValue;
               }else{
        
                   return -Double.compare(e1.getSalary(),e2.getSalary());
               }
    
            }).forEach(System.out::println);
        }

### 6.4 步骤三：终止操作 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 7]

Collector需要使用Collectors提供实例  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 8]

//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)——检查是否至少匹配一个元素。
        //         练习：是否存在员工的工资大于 10000
        boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
        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.parallelStream().findAny();
        System.out.println(employee1);
    
    }
    
    @Test
    public void test2(){
        
        List<Employee> employees = EmployeeData.getEmployees();
        // count——返回流中元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);
        //        max(Comparator c)——返回流中最大值
        //        练习：返回最高的工资：
        Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
        Optional<Double> maxSalary = salaryStream.max(Double::compare);
        System.out.println(maxSalary);
        //        min(Comparator c)——返回流中最小值
        //        练习：返回最低工资的员工
        Optional<Employee> employee = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(employee);
        System.out.println();
        //        forEach(Consumer c)——内部迭代
        employees.stream().forEach(System.out::println);
    
        //使用集合的遍历操作
        employees.forEach(System.out::println);
    }
    
    //2-归约
    @Test
    public void test3(){
        
        //        reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回 T
        //        练习1：计算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) ——可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
        //        练习2：计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<Double> salaryStream = employees.stream().map(Employee::getSalary);
        //        Optional<Double> sumMoney = salaryStream.reduce(Double::sum);
        Optional<Double> sumMoney = salaryStream.reduce((d1,d2) -> d1 + d2);
        System.out.println(sumMoney.get());
    
    }
    
    //3-收集
    @Test
    public void test4(){
        
        //        collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
        //        练习1：查找工资大于6000的员工，结果返回为一个List或Set
    
        List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> employeeList = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
    
        employeeList.forEach(System.out::println);
        System.out.println();
        Set<Employee> employeeSet = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
    
        employeeSet.forEach(System.out::println);
    }

## ⑦ Parallel-Streams 并行流 ##

`stream` 流是支持**顺序**和**并行**的。顺序流操作是单线程操作，而并行流是通过多线程来处理的，能够充分利用物理机 多核 CPU 的优势，同时处理速度更快。

*  创建一个包含 1000000 UUID list 集合。
 *  顺序流排序
 *  并行流排序

@Test
    public void  testParallelStream(){
        
        int max = 1000000;
        List<String> values = new ArrayList<>(max);
        for (int i = 0; i < max; i++) {
        
            UUID uuid = UUID.randomUUID();
            values.add(uuid.toString());
        }
    
        // 纳秒
        long t0 = System.nanoTime();
    
        long count = values.stream().sorted().count();
        System.out.println(count);
    
        long t1 = System.nanoTime();
    
        // 纳秒转微秒
        long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
        System.out.println(String.format("顺序流排序耗时: %d ms", millis)); // 1028 ms
    
        // 纳秒
        long t2 = System.nanoTime();
    
        long count2 = values.parallelStream().sorted().count();
        System.out.println(count2);
    
        long t3 = System.nanoTime();
    
        // 纳秒转微秒
        long millis1 = TimeUnit.NANOSECONDS.toMillis(t3 - t2);
        System.out.println(String.format("并行流排序耗时: %d ms", millis1)); // 815 ms
    }

同样的逻辑处理，通过并行流，我们的性能提升了近 **50%**。完成这一切，我们需要做的仅仅是将 `stream` 改成了 `parallelStream`。

## ⑨ Optional类的使用 ##

### 9.1 理解 ###

`Optional` 它不是一个函数式接口，设计它的目的是为了防止空指针异常（`NullPointerException`）

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

### 9.2 常用方法 ###

@Test
    public void test1(){
        
        //empty():创建的Optional对象内部的value = null
        Optional<Object> op1 = Optional.empty();
        if(!op1.isPresent()){
        //Optional封装的数据是否包含数据
            System.out.println("数据为空");
    
        }
        System.out.println(op1);   // Optional.empty
        System.out.println(op1.isPresent());  // false
        // 如果Optional封装的数据value为空，则get()报错。否则，value不为空时，返回value.
        // System.out.println(op1.get());
    }
    
    @Test
    public void test2(){
        
        String str = "hello";
        // str = null;
        // of(T t):封装数据t生成Optional对象。要求t非空，否则报错。
        Optional<String> op1 = Optional.of(str);
        //get()通常与of()方法搭配使用。用于获取内部的封装的数据value
        String str1 = op1.get();
        System.out.println(str1); // hello
    }
    
    @Test
    public void test3(){
        
        String str = "beijing";
        str = null;
        //ofNullable(T t) ：封装数据t赋给Optional内部的value。不要求t非空
        Optional<String> op1 = Optional.ofNullable(str);
        //orElse(T t1):如果Optional内部的value非空，则返回此value值。如果
        //value为空，则返回t1.
        String str2 = op1.orElse("shanghai");
        System.out.println(str2); // shanghai
    }

### 9.3 典型练习 ###

能保证如下的方法执行中不会出现空指针的异常

//使用Optional类的getGirlName():
    public String getGirlName2(Boy boy){
        
    
        Optional<Boy> boyOptional = Optional.ofNullable(boy);
        //此时的boy1一定非空
        Boy boy1 = boyOptional.orElse(new Boy(new Girl("迪丽热巴")));
    
        Girl girl = boy1.getGirl();
    
        Optional<Girl> girlOptional = Optional.ofNullable(girl);
        //girl1一定非空
        Girl girl1 = girlOptional.orElse(new Girl("古力娜扎"));
    
        return girl1.getName();
    }
    
    @Test
    public void test5(){
        
        Boy boy = null;
        boy = new Boy();
        boy = new Boy(new Girl("苍老师"));
        String girlName = getGirlName2(boy);
        System.out.println(girlName);
    
    }

## ⑩ Map集合 ##

`Map` 是不支持 `Stream` 流的，因为 `Map` 接口并没有像 `Collection` 接口那样，定义了 `stream()` 方法。但是，我们可以对其 `key`, `values`, `entry` 使用 流操作，如 `map.keySet().stream()`, `map.values().stream()` 和 `map.entrySet().stream()`

JDK 8 中对 `map` 提供了一些其他新特性:

Map<Integer, String> map = new HashMap<>();
    
    for (int i = 0; i < 10; i++) {
        
        // 与老版不同的是，putIfAbent() 方法在 put 之前，
        // 会判断 key 是否已经存在，存在则直接返回 value, 否则 put, 再返回 value
        map.putIfAbsent(i, "val" + i);
    }
    
    // forEach 可以很方便地对 map 进行遍历操作
    map.forEach((key, value) -> System.out.println(value));

除了上面的 `putIfAbsent()` 和 `forEach()` 外，我们还可以很方便地对某个 `key` 的值做相关操作：

// computeIfPresent(), 当 key 存在时，才会做相关处理
    // 如下：对 key 为 3 的值，内部会先判断值是否存在，存在，则做 value + key 的拼接操作
    map.computeIfPresent(3, (num, val) -> val + num);
    map.get(3);             // val33
    
    // 先判断 key 为 9 的元素是否存在，存在，则做删除操作
    map.computeIfPresent(9, (num, val) -> null);
    map.containsKey(9);     // false
    
    // computeIfAbsent(), 当 key 不存在时，才会做相关处理
    // 如下：先判断 key 为 23 的元素是否存在，不存在，则添加
    map.computeIfAbsent(23, num -> "val" + num);
    map.containsKey(23);    // true
    
    // 先判断 key 为 3 的元素是否存在，存在，则不做任何处理
    map.computeIfAbsent(3, num -> "bam");
    map.get(3);             // val33

关于删除操作，JDK 8 中提供了能够新的 `remove()` API:

map.remove(3, "val3");
    map.get(3);             // val33
    
    map.remove(3, "val33");
    map.get(3);             // null

如上代码，只有当给定的 `key` 和 `value` 完全匹配时，才会执行删除操作。

关于添加方法，JDK 8 中提供了带有默认值的 `getOrDefault()` 方法：

// 若 key 42 不存在，则返回 not found
    map.getOrDefault(42, "not found");  // not found

对于 `value` 的合并操作也变得更加简单：

// merge 方法，会先判断进行合并的 key 是否存在，不存在，则会添加元素
    map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
    map.get(9);             // val9
    
    // 若 key 的元素存在，则对 value 执行拼接操作
    map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
    map.get(9);             // val9concat

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210429195414324.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210429195420805.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2021042919535869.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2021042919534163.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210429195257271.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/202104291953044.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210429195230382.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20210429195240398.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20210429195202370.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw,size_16,color_FFFFFF,t_70