Java 8 之 Stream 相关

川长思鸟来 2022-12-27 08:42 177阅读 0赞

博文内容和示例以及图片均参考自：[https://zhuanlan.zhihu.com/p/285237824?utm\_source=wechat\_session&utm\_medium=social&utm\_oi=1087860225041776640&utm\_campaign=shareopn][https_zhuanlan.zhihu.com_p_285237824_utm_source_wechat_session_utm_medium_social_utm_oi_1087860225041776640_utm_campaign_shareopn]

在此表示感谢，如有侵权，请联系删除！！

**Stream 概述**

Java 8 版本是一个非常成功的版本，此版本中新增的 Stream 和 Lambda，为我们平时对集合（Collection）的操作提供了非常大的便利。Stream是将要处理的元素集合看成一种流，在流的过程中，借助 Stream API 提供的方法对流中的元素进行相应的操作，这些操作包括但不限于如筛选、排序、聚合等。

Stream 的几个特性：

*  stream 不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果；
 *  stream 不会改变数据源，通常情况下会产生一个新的集合或一个值；
 *  stream 具有延迟执行的特性，只有调用终端操作时，中间操作才会执行

**Stream 的创建**

stream 可以通过集合数组去创建

通过 java.util.Collection.stream() 方法用集合创建流

List<String> listStr = Arrays.asList("a","b","c","d");
    //创建一个顺序流
    Stream<String> stream = listStr.stream();
    //创建一个并行流
    Stream<String> parallelStream = listStr.parallelStream();

使用 java.util.Arrays.stream(T\[\] array) 方法用数组创建流

int arr[] = {1,2,3,4,5};
    IntStream stream = Arrays.stream(arr);

使用 Stream 的静态方法 of()、iterate()、generate() 创建 stream

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
    System.out.println("输出 stream 为：");
    stream.forEach(System.out::println);
    Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
    System.out.println("输出 stream2 为：");
    stream2.forEach(System.out::println);
    Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
    System.out.println("输出 stream3 为：");
    stream3.forEach(System.out::println);

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70][]

stream（顺序流）和 parallelStream（并行流）的区别在于：stream 是顺序流，由主线程按顺序对流执行相应操作，而 parallelStream 是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据对于处理没有顺序要求。以筛选集合中的奇数为例，来说明顺序流与并行流的区别：

![48f2842417017059c349f5e5309e27c4.png][]

如果流中的数据量足够大，那么并行流的处理效果是非常明显的。

**Stream 使用之遍历与匹配（foreach、find、match）**

stream 是支持类似集合的遍历和匹配元素的，只是 stream 中的元素是以 Optional 类型存在的。Optional 类是一个可以为 null 的容器对象，如果值存在则 isPresent() 方法会返回 true，调用 get() 方法会返回该对象。

![41f861d359d9ca5ca93ef92acedf680a.png][]

import java.util.Arrays;
    import java.util.List;
    import java.util.Optional;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
            // 遍历输出大于6的元素
            list.stream().filter(x -> x > 6).forEach(System.out::println);
            // 匹配第一个大于7的元素
            Optional<Integer> findFirst = list.stream().filter(x -> x > 7).findFirst();
            // 匹配任意（适用于并行流）大于3的元素
            Optional<Integer> findAny = list.parallelStream().filter(x -> x > 3).findAny();
            // 是否包含符合特定条件（小于6）的元素
            boolean anyMatch = list.stream().anyMatch(x -> x < 6);
            System.out.println("匹配第一个值：" + findFirst.get());
            System.out.println("匹配任意一个值：" + findAny.get());
            System.out.println("是否存在小于6的值：" + anyMatch);
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 1][]

**Stream 使用之筛选（filter）**

筛选，简单来讲就是按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作。

![493d1d808bc258c0e5c377547182f52d.png][]

import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Stream;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            List<Integer> list = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
            Stream<Integer> stream = list.stream();
            System.out.println("大于7的元素有：");
            stream.filter(x -> x > 7).forEach(System.out::println);
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 2][]

**Stream 使用之聚合（max、min、count）**

在 MySQL 中，我们经常使用 max、min 和 count 来进行数据统计。在 Java Stream 中也引入了这些概念和用法，为我们对集合、数组的数据统计工作提供了极大的便利。

![005b2c0ea9033765e10303dcf3b47f52.png][]

例：获取 String 类型的集合中长度最长的元素

import java.util.Arrays;
    import java.util.Comparator;
    import java.util.List;
    import java.util.Optional;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            List<String> list = Arrays.asList("abcd", "ads", "admin", "Java", "Java Stream");
            System.out.println("list = " + list);
            Optional<String> max = list.stream().max(Comparator.comparing(String::length));
            System.out.println("其中最长的元素是：" + max.get());
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 3][]

例：获取 Integer 类型的集合中的最大值

import java.util.Arrays;
    import java.util.Comparator;
    import java.util.List;
    import java.util.Optional;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);
            // 自然排序
            Optional<Integer> max = list.stream().max(Integer::compareTo);
            // 自定义排序
            Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() {
                @Override
                public int compare(Integer a, Integer b) {
                    return a.compareTo(b);
                }
            });
            System.out.println("自然排序的最大值：" + max.get());
            System.out.println("自定义排序的最大值：" + max2.get());
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 4][]

例：获取集合中符合某特定条件的元素个数

import java.util.Arrays;
    import java.util.List;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            List<Integer> list = Arrays.asList(7, 6, 4, 8, 2, 11, 9);
            System.out.println("list = " + list);
            long count = list.stream().filter(x -> x > 6).count();
            System.out.println("list中大于6的元素个数：" + count);
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 5][]

**Stream 使用之映射（map/flatMap）**

映射，即是可以将一个流的元素按照一定的映射规则映射到另一个流中，分为 map 和 flatMap：

*  map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素；
 *  flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

![0d4d0c45186b7d4d1f105e084b0db613.png][] ![eff97ceaea20884fb4c3edb33221ee3d.png][]

例：将英文字符串数组的元素全部改为大写，整数数组每个元素 + 3

import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            // String 数组
            String[] strArr = { "abcd", "asd", "xyzz", "java" };
            List<String> strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());
            // 整数数组
            List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);
            List<Integer> intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList());
            System.out.println("转换为大写之后的String数组：" + strList);
            System.out.println("每个元素 +3 之后的整数数组：" + intListNew);
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 6][]

例：将两个字符数组合并成一个新的字符数组：

import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");
            List<String> listNew = list.stream().flatMap(s -> {
                // 将每个元素转换成一个stream
                String[] split = s.split(",");
                Stream<String> s2 = Arrays.stream(split);
                return s2;
            }).collect(Collectors.toList());
            System.out.println("合并前：" + list);
            System.out.println("合并后：" + listNew);
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 7][]

**Stream 使用之归约（reduce）**

所谓归约，也称缩减，即是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值的操作。

![1ae95a2c7ad26bc0f77276b60d1eac2f.png][]

例：求整数集合中的各个元素的和、乘积和最大值

import java.util.Arrays;
    import java.util.List;
    import java.util.Optional;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
            // 求和方式1
            Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
            // 求和方式2
            Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
            // 求和方式3
            Integer sum3 = list.stream().reduce(0, Integer::sum);
            // 求乘积
            Optional<Integer> product = list.stream().reduce((x, y) -> x * y);
            // 求最大值方式1
            Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
            // 求最大值写法2
            Integer max2 = list.stream().reduce(1, Integer::max);
    
            System.out.println("sum = " + sum.get() + "," + sum2.get() + "," + sum3);
            System.out.println("mul = " + product.get());
            System.out.println("max = " + max.get() + "," + max2);
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 8][]

**Stream 使用之收集（collect）**

collect，意为收集。关于 collect，可以说是内容最多、功能最丰富的部分了。收集，即是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。使用一个新的例子来说明 collect 的使用。

public class Person {
        private String name;  // 姓名
        private int salary; // 薪资
        private int age; // 年龄
        private String sex; //性别
        private String area;  // 地区
    
        // 构造方法
        public Person(String name, int salary, int age,String sex,String area) {
            this.name = name;
            this.salary = salary;
            this.age = age;
            this.sex = sex;
            this.area = area;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getSalary() {
            return salary;
        }
    
        public void setSalary(int salary) {
            this.salary = salary;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public String getArea() {
            return area;
        }
    
        public void setArea(String area) {
            this.area = area;
        }
    }

**归集（toList/toSet/toMap）**

因为流不存储数据，那么在流中的数据完成处理后，需要将流中的数据重新归集到新的集合里，最常用的是 toList、toSet、toMap。

package demo;
    
    import java.util.*;
    import java.util.stream.Collectors;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
            // 输出 list 中的偶数
            List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
            // 输出 list 中的偶数，不重复
            Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());
    
            List<Person> personList = new ArrayList<Person>();
            personList.add(new Person("Tom", 8900, 23, "male", "New York"));
            personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
            personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
            personList.add(new Person("Anni", 8200, 24, "female", "New York"));
            personList.add(new Person("Owen", 9500, 25, "male", "New York"));
            personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
            // 将员工中工资 > 8000 的员工姓名输出
            Map<?, Person> map = personList.stream().filter(p -> p.getSalary() > 8000)
                    .collect(Collectors.toMap(Person::getName, p -> p));
            System.out.println("toList:" + listNew);
            System.out.println("toSet:" + set);
            System.out.println("toMap:" + map);
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 9][]

**统计（count/averaging）**

Collectors 提供了一系列用于数据统计的静态方法：如，计数、平均值、最值、求和、统计等。例：统计员工人数、平均工资、工资总额、最高工资

import java.util.*;
    import java.util.stream.Collectors;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            List<Person> personList = new ArrayList<Person>();
            personList.add(new Person("Tom", 8900, 23, "male", "New York"));
            personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
            personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
            personList.add(new Person("Anni", 8200, 24, "female", "New York"));
            personList.add(new Person("Owen", 9500, 25, "male", "New York"));
            personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
            // 求员工总数
            Long count = personList.stream().collect(Collectors.counting());
            // 求平均工资
            Double averageSalary = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
            // 求最高工资
            Optional<Integer> maxSalary = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
            // 求工资之和
            Integer sumSalary = personList.stream().collect(Collectors.summingInt(Person::getSalary));
            // 一次性统计所有信息
            DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));
            System.out.println("员工总数为：" + count);
            System.out.println("员工平均工资为：" + averageSalary);
            System.out.println("员工最高工资为：" + maxSalary);
            System.out.println("员工工资总和为：" + sumSalary);
            System.out.println("员工工资所有统计：" + collect);
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 10][]

**分组（partitioningBy/groupingBy）**

*  partitioningBy：分区。将 stream 按条件分为两个 map，比如将员工按工资是否高于8000分为两部分；
 *  groupingBy：分组。将集合分为多个 map，比如将员工按照性别分组。

![01ea34598ec576577dadeea63995d2c5.png][]

import java.util.*;
    import java.util.stream.Collectors;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            List<Person> personList = new ArrayList<Person>();
            personList.add(new Person("Tom", 8900, 23, "male", "New York"));
            personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
            personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
            personList.add(new Person("Anni", 8200, 24, "female", "New York"));
            personList.add(new Person("Owen", 9500, 25, "male", "New York"));
            personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
            // 将员工按薪资是否高于8000分组
            Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
            System.out.println("员工按薪资是否大于8000分组情况：");
            System.out.println(part);
            Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
            System.out.println("员工按性别分组情况：");
            System.out.println(group);
            // 将员工先按性别分组，再按地区分组
            Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
            System.out.println("员工按性别、地区：");
            System.out.println(group2);
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 11][]

**接合（joining）**

joining 可以将 stream 中的元素用特定的连接符连接成一个字符串

import java.util.*;
    import java.util.stream.Collectors;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            List<String> list = Arrays.asList("A", "B", "C");
            String string = list.stream().collect(Collectors.joining("-"));
            System.out.println("拼接后的字符串：" + string);
    
            List<Person> personList = new ArrayList<Person>();
            personList.add(new Person("Tom", 8900, 23, "male", "New York"));
            personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
            personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
            personList.add(new Person("Anni", 8200, 24, "female", "New York"));
            personList.add(new Person("Owen", 9500, 25, "male", "New York"));
            personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
            String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
            System.out.println("所有员工的姓名：" + names);
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 12][]

**归约（reducing）**

Collectors 类提供的 reducing 方法，相比于 stream 本身的 reduce 方法，增加了对自定义归约的支持

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 13][]

**排序（sorted）**

sorted()：自然排序，流中元素需要实现 Comparable 接口

sorted(Comparator com)：Comparator 排序器自定义排序

例：将员工按照工资排序

import java.util.*;
    import java.util.stream.Collectors;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            List<Person> personList = new ArrayList<Person>();
            personList.add(new Person("Tom", 8900, 23, "male", "New York"));
            personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
            personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
            personList.add(new Person("Anni", 8200, 24, "female", "New York"));
            personList.add(new Person("Owen", 9500, 25, "male", "New York"));
            personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
            // 按工资升序排序
            List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName)
                    .collect(Collectors.toList());
            // 按工资降序排序
            List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed())
                    .map(Person::getName).collect(Collectors.toList());
            // 先按工资再按年龄自然排序（降序）
            List<String> newList3 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed())
                    .map(Person::getName).collect(Collectors.toList());
            // 先按工资再按年龄自定义排序（升序）
            List<String> newList4 = personList.stream().sorted((p1, p2) -> {
                if (p1.getSalary() == p2.getSalary()) {
                    return p2.getAge() - p1.getAge();
                } else {
                    return p1.getSalary() - p2.getSalary();
                }
            }).map(Person::getName).collect(Collectors.toList());
            System.out.println("按工资升序自然排序：" + newList);
            System.out.println("按工资降序排序：" + newList2);
            System.out.println("先按工资再按年龄自然排序：" + newList3);
            System.out.println("先按工资再按年龄自定义排序：" + newList4);
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 14][]

**提取/组和**

流也可以进行合并、去重、限制、跳过等操作

![6a909d45f8a81c9fe69f04a3e4cd784d.png][] ![77d4b4df323bf4e96dae0e2804d9a459.png][] ![44b0cc450d284b61545feb3f8e2a04cf.png][]

package demo;
    
    import java.util.*;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            String[] arr1 = { "a", "b", "c", "d" };
            String[] arr2 = { "d", "e", "f", "g" };
            String[] arr3 = {"A", "B", "C", "D"};
            String[] arr4 = {"D", "E", "F", "G"};
            Stream<String> stream1 = Stream.of(arr1);
            Stream<String> stream2 = Stream.of(arr2);
            Stream<String> stream3 = Stream.of(arr3);
            Stream<String> stream4 = Stream.of(arr4);
            // concat:合并两个流
            List<String> listConcat = Stream.concat(stream1,stream2).collect(Collectors.toList());
            System.out.println("合并两个流：" + listConcat);
            // concat:合并两个流 distinct：去重
            List<String> listDistinct = Stream.concat(stream3, stream4).distinct().collect(Collectors.toList());
            System.out.println("合并两个流并去重：" + listDistinct);
            // limit：限制从流中获得前n个数据
            // 从1开始，获取10个逐个+2的数
            List<Integer> limit = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
            System.out.println("limit：" + limit);
            // skip：跳过前n个数据
            // 从1开始，获取5个逐个+2的数，但是跳过第一个
            List<Integer> skip= Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());
            System.out.println("skip：" + skip);
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 15][]

想要了解更多关于 Java 8 语法的示例，请移步至：[https://blog.csdn.net/jiaomubai/article/details/111031943][https_blog.csdn.net_jiaomubai_article_details_111031943]

[https_zhuanlan.zhihu.com_p_285237824_utm_source_wechat_session_utm_medium_social_utm_oi_1087860225041776640_utm_campaign_shareopn]: https://zhuanlan.zhihu.com/p/285237824?utm_source=wechat_session&utm_medium=social&utm_oi=1087860225041776640&utm_campaign=shareopn
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70]: /images/20221120/e2277d23d1724d369910f992e507bf97.png
[48f2842417017059c349f5e5309e27c4.png]: /images/20221120/6e8f91820805474ea83fd2c57b5c71fc.png
[41f861d359d9ca5ca93ef92acedf680a.png]: /images/20221120/0e495422c53449a2b719e03527841e8a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 1]: /images/20221120/257ab28e8c56402aa3f35e170b5412a4.png
[493d1d808bc258c0e5c377547182f52d.png]: /images/20221120/396a23673cfe41edbe7e497f29430474.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 2]: /images/20221120/a9f855a5f8494680851a227aadffc62b.png
[005b2c0ea9033765e10303dcf3b47f52.png]: /images/20221120/3e50844b0ac5417f9a0a6e190eeb98a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 3]: /images/20221120/2400ca54cb2a4d2f9b14c4786eb19fe6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 4]: /images/20221120/6d761f4b9c7547d59dd43e067973ada9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 5]: /images/20221120/56d63efc5af649d6ab045dbed43e8008.png
[0d4d0c45186b7d4d1f105e084b0db613.png]: https://img-blog.csdnimg.cn/img_convert/0d4d0c45186b7d4d1f105e084b0db613.png
[eff97ceaea20884fb4c3edb33221ee3d.png]: /images/20221120/fe2699b554b3420094bb34a4e4750771.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 6]: /images/20221120/7618dc37e29a4e73b24aa22acad9dabe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 7]: /images/20221120/432388235aa347a598a63e99182dd73c.png
[1ae95a2c7ad26bc0f77276b60d1eac2f.png]: /images/20221120/5f247c3825ba4f85a77d32bc6337db61.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 8]: /images/20221120/b1967404ea0348eeaae1865e4a4ef66a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 9]: /images/20221120/eb1e7c61576a4a5fad60b90825ba2f9a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 10]: /images/20221120/839a3777969348c1a95b7c2a8c235a18.png
[01ea34598ec576577dadeea63995d2c5.png]: /images/20221120/5a1e2e68fa3749a7b8f916d69f4398d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 11]: /images/20221120/3005c785299b474482d3915dcf66e3c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 12]: /images/20221120/58fa2d6b3fa34d4d9af1b4fcc407baa0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 13]: /images/20221120/71ff6fc9e1d64a6b84921bedbfb55450.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 14]: /images/20221120/2b168a4c5d804cb68fba5b174c134a0b.png
[6a909d45f8a81c9fe69f04a3e4cd784d.png]: https://img-blog.csdnimg.cn/img_convert/6a909d45f8a81c9fe69f04a3e4cd784d.png
[77d4b4df323bf4e96dae0e2804d9a459.png]: https://img-blog.csdnimg.cn/img_convert/77d4b4df323bf4e96dae0e2804d9a459.png
[44b0cc450d284b61545feb3f8e2a04cf.png]: /images/20221120/a15fce6fd9b94cfa9117b8206cced062.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 15]: /images/20221120/0e137783e8aa4b75b8547b439590fa8b.png
[https_blog.csdn.net_jiaomubai_article_details_111031943]: https://blog.csdn.net/jiaomubai/article/details/111031943