JDK1.8新特性之Stream流

Bertha 。 2023-01-10 14:35 175阅读 0赞

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

## 什么是 Stream？ ##

Stream（流）是一个来自数据源的元素队列并支持聚合操作

*  元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
 *  **数据源** 流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。
 *  **聚合操作** 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。

和以前的Collection操作不同， Stream操作还有两个基础的特征：

*  **Pipelining**: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
 *  **内部迭代**： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

**注意：**

*  Stream流自己不会存储元素
 *  Stream流不会改变源数据。相反，它会返回一个持有结果的新Stream
 *  Stream操作是延迟执行的，这意味着它们需要等到需要结果的时候才会执行（提升了程序的执行效率）

## 2、Stream流操作 ##

有3个步骤，依次为获取Stream、中间操作、终止操作。

2.1 获取Stream

有4种方式

1.  通过集合获取Stream  
    Collection接口中的默认方法stream()获取串行流或parallelStream()获取并行流  
    Map集合如何获取流  
        map.keySet().stream();  
        map.values().stream();  
        map.entrySet().stream();
2.  通过数组获取Stream  
    Arrays中的静态方法String(T\[\] array)
3.  通过一个或多个同类型元素获取Stream  
    Stream接口中的静态方法of(T… values)
4.  获取无穷序列流  
    static Stream iterator(T seed, UnaryOperator f)  
    返回一个无穷序列有序流，其中第一个元素由seed指定，后面的元素由一元运算符f计算得到，可以实现迭代操作  
    static Stream generate(Supplier s)  
    返回一个无穷序列无序流，其中每个元素是由提供Supplier生成。适用于产生恒定的流，随机元素的流等。

示例代码如下：

package com.demo.stream.day1;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.Random;
    import java.util.stream.Stream;
    
    public class Demo1 {
        public static void main(String[] args) {
            // 数据源
            List<String> list = Arrays.asList("Tom", "Jerry", "Tony");
            String[] names = { "Tom", "Jerry", "Tony" };
            // 1、获取集合的流对象
            Stream<String> sm1 = list.stream();
            System.out.println("sm1集合流为："+sm1);
            // 2、获取数组的流对象
            Stream<String> sm2 = Arrays.stream(names);
            System.out.println("sm2集合流为："+sm2);
            // 3、获取多个元素的流对象
            Stream<String> sm3 = Stream.of("Tom", "Jerry", "Tony");
            System.out.println("sm3集合流为："+sm3);
            // 4、获取无穷序列流对象
            Stream<Integer> sm4 = Stream.iterate(1, x -> x + 2);// 迭代
            sm4.limit(10).forEach(System.out::println);
    
            Stream<Integer> sm5 = Stream.generate(new Random()::nextInt);// 生成
            sm5.limit(10).forEach(System.out::println);
        }
    }
    
    以上输出结果为：
    sm1集合流为：java.util.stream.ReferencePipeline$Head@677327b6
    sm2集合流为：java.util.stream.ReferencePipeline$Head@14ae5a5
    sm3集合流为：java.util.stream.ReferencePipeline$Head@7f31245a
    1
    3
    5
    7
    9
    11
    13
    15
    17
    19
    1946888291
    -1090808119
    -2116522392
    -267620561
    -2113301705
    -825118509
    -411018441
    -1873966901
    -347306633
    -312618252

2.2 中间操作

中间操作返回Stream,多个中间操作可以连接起来形成一个流水线。除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时，所有中间操作会一次性全部处理，这种操作称为“惰性求值”。  
常见的中间操作有下面几类：  
1）筛选与切片

*  filter(Predicate pre)：过滤
 *  limit(long maxSize)：取用前几个
 *  skip(long n)：跳过前几个
 *  distinct()：根据对象的hashCode()和equals()去除重复

示例代码如下：

package com.demo.stream.day1;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class Demo2 {
        public static void main(String[] args) {
            //数据源
            List<String> list = Arrays.asList("Tom","Jerry","Tony","Tom","Tank");
            //filter：获取所有以"T"开头的名字
            list.stream()
                    .filter(s->s.startsWith("T"))
                    .forEach(System.out::println);
            System.out.println("=============我是分隔线=============");
            //limit：获取前2个以"T"开头的名字
            list.stream()
                    .filter(s->s.startsWith("T"))
                    .limit(2)
                    .forEach(System.out::println);
            System.out.println("=============我是分隔线=============");
            //skip：获取以"T"开头的名字（跳过前2个）
            list.stream()
                    .filter(s->s.startsWith("T"))
                    .skip(2)
                    .forEach(System.out::println);
            System.out.println("=============我是分隔线=============");
            //distinct：获取以"T"开头的名字（去除重复）
            list.stream()
                    .filter(s->s.startsWith("T"))
                    .distinct()
                    .forEach(System.out::println);
        }
    }
    以上输出结果如下：
    Tom
    Tony
    Tom
    Tank
    =============我是分隔线=============
    Tom
    Tony
    =============我是分隔线=============
    Tom
    Tank
    =============我是分隔线=============
    Tom
    Tony
    Tank

2）映射：map

*  <R> Stream map(Function<? super T, ? extends R> mapper);  
    将流中的每一个元素通过mapper函数转换成其它类型的数据
 *  <R> Stream flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);  
    将流中的每一个元素都转成另一个流，然后将所有流连接成一个新流

示例代码如下：

package com.demo.stream.day1;
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Stream;
    //需求1：将集合中每个元素转成大写
    public class DemoStreamMap {
        public static void main(String[] args) {
            List<String> list = Arrays.asList("Tom","Jerry","Tony","Tom","Tank");
            Stream<String> sm = list.stream().map(String::toUpperCase);
            sm.forEach(System.out::println);
        }
    }

package com.demo.stream.day1;
    import org.junit.Test;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Stream;
    //需求2：将集合元素的每个字符依次输出
    public class Demo2StreamMap {
            @Test
            public void test(){
                List<String> list = Arrays.asList("Tom","Jerry","Tony","Tom","Tank");
                Stream<Stream<Character>> sm = list.stream().map(s->new Demo2StreamMap().mapMethod(s));
                sm.forEach(stm->stm.forEach(System.out::println));
                //使用map的操作有些复杂，我们可以通过flatMap()进行改进
                Stream<Character> sm2 = list.stream().flatMap(new Demo2StreamMap()::mapMethod);
                sm2.forEach(System.out::println);
            }
            //将指定的字符串转成流
            public Stream<Character> mapMethod(String s){
                List<Character> list = new ArrayList<>();
                for(int i=0;i<s.length();i++){
                    list.add(s.charAt(i));
                }
                return list.stream();
            }
        }

3）排序：sorted

*  sorted():自然排序
 *  sorted(Comparator comparator):比较器排序

示例代码如下：

package com.demo.stream.day1;
    import java.util.Arrays;
    import java.util.List;
    public class StreamSort {
        public static void main(String[] args) {
            List<String> list = Arrays.asList("Tom","Jerry","Tony","Tank");
    
            //自然排序
            list.stream()
                    .sorted()
                    .forEach(System.out::println);
            System.out.println("==================");
            //比较器排序
            list.stream()
                    .sorted((s1,s2)->s2.compareTo(s1))
                    .forEach(System.out::println);
        }
    }
    输出结果：
    Jerry
    Tank
    Tom
    Tony
    ==================
    Tony
    Tom
    Tank
    Jerry

2.3 终止操作

终止操作会从流的流水线生成结果，其结果可以是任何不是流的值。  
常见的终止操作有下面几类：  
1）匹配

*  allMatch(Predicate pre)：检查是否匹配所有元素
 *  angMatch(Predicate pre)：检查是否至少匹配一个元素
 *  noneMatch(Predicate pre)：检查是否没有匹配所有元素

示例代码如下：

package com.demo.stream.day1.endHandle;
    /**
     * 员工类
     */
    public class Employee {
        private String name;//姓名
        private double salary;//薪水
        private Status status;//状态
        //有参构造
        public Employee(String name, double salary, Status status) {
            this.name = name;
            this.salary = salary;
            this.status = status;
        }
        //getter and setter
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getSalary() {
            return salary;
        }
    
        public void setSalary(double salary) {
            this.salary = salary;
        }
    
        public Status getStatus() {
            return status;
        }
    
        public void setStatus(Status status) {
            this.status = status;
        }
    
        public enum Status{
            FREE,//空闲
            BUSY,//忙
            VACATION;//休假
        }
    }

package com.demo.stream.day1.endHandle;
    
    import org.junit.Test;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class EmployeeStream {
        //数据源：所有终止操作示例代码使用同一数据源，下面不会重复
        List<Employee> employees = Arrays.asList(
                new Employee("Tom", 6000, Employee.Status.BUSY),
                new Employee("Jerry", 5000, Employee.Status.BUSY),
                new Employee("Tony", 9000, Employee.Status.VACATION),
                new Employee("Lucy", 8000, Employee.Status.BUSY),
                new Employee("Habi", 7000, Employee.Status.BUSY)
        );
    //匹配操作
    @Test
    public void test1(){
    //检查是否所有人都在忙
    boolean b1 = employees.stream().allMatch(e->e.getStatus().equals(Employee.Status.BUSY));
    System.out.println("b1:"+b1);//输出结果:false
    
    //检查是否至少有一个人在休假
    boolean b2 = employees.stream().anyMatch(e->e.getStatus().equals(Employee.Status.VACATION));
    System.out.println("b2:"+b2);//输出结果:true
    
    //检查是否所有人都不在空闲
    boolean b3 = employees.stream().noneMatch(e->e.getStatus().equals(Employee.Status.FREE));
    System.out.println("b3:"+b3);//输出结果:true
    }
    
    
    }

2）查找

*  Optional findFist()：返回第一个元素
 *  Optional findAny()：返回任意一个元素
 *  long count()：返回流中元素的总个数
 *  Optional max(Comparator comparator)：返回流中最大值
 *  Optional min(Comparator comparator)：返回流中最小值

注：Optional是一种容器，里面可以存储对象，用来解决空指针异常。关于Optional的一些常见用法及应用，可点击[Java之JDK1.8新特性四（Optional）][Java_JDK1.8_Optional]了解。

示例代码如下：

package com.demo.stream.day1.endHandle;
    
    import org.junit.Test;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.Optional;
    public class EmployeeStreamFind {
        //数据源：所有终止操作示例代码使用同一数据源，下面不会重复
        List<Employee> employees = Arrays.asList(
                new Employee("Tom", 6000, Employee.Status.BUSY),
                new Employee("Jerry", 5000, Employee.Status.BUSY),
                new Employee("Tony", 9000, Employee.Status.VACATION),
                new Employee("Lucy", 8000, Employee.Status.BUSY),
                new Employee("Habi", 7000, Employee.Status.BUSY)
        );
        //查找操作
        @Test
        public void test2(){
        //1、获取工资最高的那个员工
        //tips:Optional是一个容器，可以减少空指针异常。如果容器为空，可以通过它提供的orElse(T other)方法，将other添加到容器中
            Optional<Employee> op = employees.stream()
                    .sorted((e1,e2)->Double.compare(e2.getSalary(), e1.getSalary()))
                    .findFirst();
            Employee emp = op.get();
            System.out.println("==============================");
        //2、获取任意一个在忙的员工
            Optional<Employee> op2 = employees.stream()
                    .filter(e->e.getStatus().equals(Employee.Status.BUSY))
                    .findAny();
            System.out.println(op2.get());
            System.out.println("==============================");
        //多执行几次上面的操作，发现每次都是第一个在忙的员工，不能获取其他在忙的员工（因为采用的是串行流）
        //将流改进为并行流，就可以解决这个问题
            Optional<Employee> op3 = employees.parallelStream()
                    .filter(e->e.getStatus().equals(Employee.Status.BUSY))
                    .findAny();
            System.out.println(op3.get());
            System.out.println("==============================");
        //3、获取流中元素的总个数
            long count = employees.stream().count();
            System.out.println(count);
    
        //4、获取工资最高的那个员工
            Optional<Employee> op4 =employees.stream()
                    .max((e1,e2)->Double.compare(e1.getSalary(), e2.getSalary()));
            System.out.println(op4.get());
            System.out.println("==============================");
        //5、获取工资最低的那个员工
            Optional<Employee> op5 =employees.stream()
                    .min((e1,e2)->Double.compare(e1.getSalary(), e2.getSalary()));
            System.out.println(op5.get());
            System.out.println("==============================");
        //获取最低工资
            Optional<Double> op6 = employees.stream()
                    .map(e -> e.getSalary())
                    .min(Double::compare);
            System.out.println(op6.get());
            System.out.println("==============================");
        }
    }
    输出结果如下:
    ==============================
    com.demo.stream.day1.endHandle.Employee@200a570f
    ==============================
    com.demo.stream.day1.endHandle.Employee@65ae6ba4
    ==============================
    5
    com.demo.stream.day1.endHandle.Employee@9e89d68
    ==============================
    com.demo.stream.day1.endHandle.Employee@65ae6ba4
    ==============================
    5000.0
    ==============================

3）归约

*  T reduce(T identity, BinaryOperator bo)  
    identity作为初始元素，参与到二元运算bo中，作为bo中第一个元素，而第二个元素来自于Stream流中的第一个元素。  
    当执行完bo操作之后，运算结果作为第一个元素，Stream流中的第二个元素作为第二元素再次执行bo操作，一直到Stream中所有  
    元素都参与了运算，最终获取了一个T类型的值
 *  Optional reduce(BinaryOperator bo)  
    将流中的所有元素依次按照二元运算bo操作执行，最终获得一个Optional容器

注：map和reduce的连接通常称为map-reduce模式（Google用它来进行网络搜索而出名）

示例代码如下：

package com.demo.stream.day1.endHandle;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Optional;
    public class EmployeeGuiYue {
        public static void main(String[] args) {
            //数据源：所有终止操作示例代码使用同一数据源，下面不会重复
            List<Employee> employees = Arrays.asList(
                    new Employee("Tom", 6000, Employee.Status.BUSY),
                    new Employee("Jerry", 5000, Employee.Status.BUSY),
                    new Employee("Tony", 9000, Employee.Status.VACATION),
                    new Employee("Lucy", 8000, Employee.Status.BUSY),
                    new Employee("Habi", 7000, Employee.Status.BUSY)
            );
            List<Integer> li = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
            //需求1：求集合li中所有元素之和
            Integer sum = li.stream().reduce(0, (x,y)->x+y);
            System.out.println(sum);
    
            //需求2：获取所有员工的总工资
            Optional<Double> op = employees.stream()
                    .map(Employee::getSalary)
                    .reduce(Double::sum);
            System.out.println(op.get());
        }
    }
    输出结果：
    55
    35000.0

4）收集  
collect(Collector c)：通过接受一个收集器（用于给Stream中元素做汇总的方法），将流转换成其它形式。

注：  
Collector接口中方法的实现决定了如何对流执行收集操作（如将元素收集到List、Map、Set等）。  
Collectors工具类中提供了很多静态方法，可以方便的创建常见收集器实例。  
常用方法有：  
1）将收集到的元素转成集合

*  toList()：转List
 *  toSet()：转Set
 *  toCollection(Supplier sup)：转指定生成的集合

2）将收集到的数据进行汇总

*  counting()：总数
 *  averagingDouble(Function mapper)：平均值
 *  summingDouble(Function mapper)：总值
 *  maxBy(Comparator comr)：最大值
 *  minBy(Comparator comr)：最小值
 *  summarizingDouble(Function mapper)：汇总结果

3）分组

*  groupingBy(Function mapper)：分组
 *  groupingBy(Function mapper, Collector clt) ：多级分组

4）分区

*  partitioningBy(Predicate pre)：分区

5）连接

*  joining()：连接
 *  joining(String delimiter)：连接且设置分隔符
 *  joining(String delimiter, String prefix, String suffix)：连接且设置分隔符、前缀和后缀

示例代码如下

1、将收集到的元素转成集合

package com.demo.stream.day1.endHandle;
    import java.util.Arrays;
    import java.util.HashSet;
    import java.util.List;
    import java.util.Set;
    import java.util.stream.Collectors;
    public class EmployeeCollector {
        public static void main(String[] args) {
            //数据源：所有终止操作示例代码使用同一数据源，下面不会重复
            List<Employee> employees = Arrays.asList(
                    new Employee("Tom", 6000, Employee.Status.BUSY),
                    new Employee("Jerry", 5000, Employee.Status.BUSY),
                    new Employee("Tony", 9000, Employee.Status.VACATION),
                    new Employee("Lucy", 8000, Employee.Status.BUSY),
                    new Employee("Habi", 7000, Employee.Status.BUSY)
            );
            //需求：获取所有员工的姓名并存储到一个List中
            List<String> list = employees.stream()
                    .map(Employee::getName)
                    .collect(Collectors.toList());
            list.forEach(System.out::println);
            System.out.println("========================");
            //需求：获取所有员工的姓名并存储到一个Set中
            Set<String> set = employees.stream()
                    .map(Employee::getName)
                    .collect(Collectors.toSet());
            set.forEach(System.out::println);
            System.out.println("========================");
            //需求：获取所有员工的姓名并存储到一个HashSet中
            HashSet<String> hs = employees.stream()
                    .map(Employee::getName)
                    .collect(Collectors.toCollection(HashSet::new));
            hs.forEach(System.out::println);
            System.out.println("========================");
        }
    }
    输出结果：
    Tom
    Jerry
    Tony
    Lucy
    Habi
    ========================
    Tony
    Habi
    Tom
    Lucy
    Jerry
    ========================
    Tony
    Habi
    Tom
    Lucy
    Jerry
    ========================

2、将收集到的数据进行汇总

package com.demo.stream.day1.endHandle;
    import java.util.Arrays;
    import java.util.DoubleSummaryStatistics;
    import java.util.List;
    import java.util.Optional;
    import java.util.stream.Collectors;
    public class EmployeeCollect {
        public static void main(String[] args) {
            //数据源：所有终止操作示例代码使用同一数据源，下面不会重复
            List<Employee> employees = Arrays.asList(
                    new Employee("Tom", 6000, Employee.Status.BUSY),
                    new Employee("Jerry", 5000, Employee.Status.BUSY),
                    new Employee("Tony", 9000, Employee.Status.VACATION),
                    new Employee("Lucy", 8000, Employee.Status.BUSY),
                    new Employee("Habi", 7000, Employee.Status.BUSY)
            );
            //需求：获取工资大于6000的员工数
            long count = employees.stream()
                    .filter(e -> e.getSalary()>6000)
                    .collect(Collectors.counting());
            System.out.println(count);
            System.out.println("========================");
        //需求：获取所有员工工资的平均值
            Double avgSalary = employees.stream()
                    .collect(Collectors.averagingDouble(Employee::getSalary));
            System.out.println(avgSalary);
            System.out.println("========================");
        //需求：获取所有员工的工资
            Double sumSalary = employees.stream()
                    .collect(Collectors.summingDouble(Employee::getSalary));
            System.out.println(sumSalary);
            System.out.println("========================");
            //需求：获取员工工资的最大值
            Optional<Double> op = employees.stream()
                    .map(Employee::getSalary)
                    .collect(Collectors.maxBy(Double::compare));
            System.out.println(op.get());
            System.out.println("========================");
        //也可以通过summarizingDouble获取总数，最大值，最小值，总值，平均值
            DoubleSummaryStatistics dss = employees.stream()
                    .collect(Collectors.summarizingDouble(Employee::getSalary));
            System.out.println(dss.getCount());
            System.out.println(dss.getMax());
            System.out.println(dss.getMin());
            System.out.println(dss.getSum());
            System.out.println(dss.getAverage());
            System.out.println("========================");
        }
    }
    输出结果如下：
    3
    ========================
    7000.0
    ========================
    35000.0
    ========================
    9000.0
    ========================
    5
    9000.0
    5000.0
    35000.0
    7000.0
    ========================

3、分组

package com.demo.stream.day1.endHandle;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    import java.util.stream.Collectors;
    public class EmployeeGroupBy {
        public static void main(String[] args) {
            //数据源：所有终止操作示例代码使用同一数据源，下面不会重复
            List<Employee> employees = Arrays.asList(
                    new Employee("Tom", 6000, Employee.Status.BUSY),
                    new Employee("Jerry", 5000, Employee.Status.BUSY),
                    new Employee("Tony", 9000, Employee.Status.VACATION),
                    new Employee("Lucy", 8000, Employee.Status.BUSY),
                    new Employee("Habi", 7000, Employee.Status.BUSY)
            );
            //需求：按员工的工作状态进行分组
            Map<Employee.Status, List<Employee>> map = employees.stream()
                    .collect(Collectors.groupingBy(Employee::getStatus));
            map.forEach((k,v) -> {
                System.out.println(k);
                v.forEach(System.out::println);
            });
        }
    }
    输出结果：
    VACATION
    com.demo.stream.day1.endHandle.Employee@34a245ab
    BUSY
    com.demo.stream.day1.endHandle.Employee@7cc355be
    com.demo.stream.day1.endHandle.Employee@6e8cf4c6
    com.demo.stream.day1.endHandle.Employee@12edcd21
    com.demo.stream.day1.endHandle.Employee@34c45dca

4、多级分组

package com.demo.stream.day1.endHandle;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    import java.util.stream.Collectors;
    public class EmployeeDuoJiGroupBy {
        public static void main(String[] args) {
            //数据源：所有终止操作示例代码使用同一数据源，下面不会重复
            List<Employee> employees = Arrays.asList(
                    new Employee("Tom", 6000, Employee.Status.BUSY),
                    new Employee("Jerry", 5000, Employee.Status.BUSY),
                    new Employee("Tony", 9000, Employee.Status.VACATION),
                    new Employee("Lucy", 8000, Employee.Status.BUSY),
                    new Employee("Habi", 7000, Employee.Status.BUSY)
            );
            //需求：先按员工的工作状态进行分组，同一状态再按工资进行分组
            Map<Employee.Status, Map<String, List<Employee>>> map = employees.stream()
                    .collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy(e -> {
                        if(((Employee) e).getSalary()<5000){
                            return "普工";
                        }else if(e.getSalary()<8000){
                            return "技工";
                        }else{
                            return "高工";
                        }
                    })));
    
            map.forEach((k,v) ->{
                System.out.println(k);
                v.forEach((s,l) -> {
                    System.out.println(s);
                    l.forEach(System.out::println);
                });
            });
    
        }
    }
    输出结果：
    BUSY
    技工
    com.demo.stream.day1.endHandle.Employee@6e8cf4c6
    com.demo.stream.day1.endHandle.Employee@12edcd21
    com.demo.stream.day1.endHandle.Employee@34c45dca
    高工
    com.demo.stream.day1.endHandle.Employee@52cc8049
    VACATION
    高工
    com.demo.stream.day1.endHandle.Employee@5b6f7412

5、分区

package com.demo.stream.day1.endHandle;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    import java.util.stream.Collectors;
    public class EmployeePartitioningBy {
        public static void main(String[] args) {
            //数据源：所有终止操作示例代码使用同一数据源，下面不会重复
            List<Employee> employees = Arrays.asList(
                    new Employee("Tom", 6000, Employee.Status.BUSY),
                    new Employee("Jerry", 5000, Employee.Status.BUSY),
                    new Employee("Tony", 9000, Employee.Status.VACATION),
                    new Employee("Lucy", 8000, Employee.Status.BUSY),
                    new Employee("Habi", 7000, Employee.Status.BUSY)
            );
            //需求：将员工分为两个区，工资>=8000的一个区，小于<8000的另一个区
            Map<Boolean, List<Employee>> map = employees.stream()
                    .collect(Collectors.partitioningBy(e -> e.getSalary()>=8000));
            map.forEach((k,v) -> {
                System.out.println(k);
                v.forEach(System.out::println);
            });
        }
    }
    输出结果：
    false
    com.demo.stream.day1.endHandle.Employee@7291c18f
    com.demo.stream.day1.endHandle.Employee@34a245ab
    com.demo.stream.day1.endHandle.Employee@7cc355be
    true
    com.demo.stream.day1.endHandle.Employee@6e8cf4c6
    com.demo.stream.day1.endHandle.Employee@12edcd21

6、连接

package com.demo.stream.day1.endHandle;
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    public class EmployeeJoining {
        public static void main(String[] args) {
            //数据源：所有终止操作示例代码使用同一数据源，下面不会重复
            List<Employee> employees = Arrays.asList(
                    new Employee("Tom", 6000, Employee.Status.BUSY),
                    new Employee("Jerry", 5000, Employee.Status.BUSY),
                    new Employee("Tony", 9000, Employee.Status.VACATION),
                    new Employee("Lucy", 8000, Employee.Status.BUSY),
                    new Employee("Habi", 7000, Employee.Status.BUSY)
            );
            //需求：将所有员工的姓名连接成一个字符串
            String s1 = employees.stream()
                    .map(Employee::getName)
                    .collect(Collectors.joining());
            System.out.println(s1);
    
        //需求：将所有员工的姓名连接成一个字符串,以','分割
            String s2 = employees.stream()
                    .map(Employee::getName)
                    .collect(Collectors.joining(","));
            System.out.println(s2);
    
        //需求：将所有员工的姓名连接成一个字符串,以','分割，且两边添加<<和>>符号
            String s3 = employees.stream()
                    .map(Employee::getName)
                    .collect(Collectors.joining(",","<<",">>"));
            System.out.println(s3);
        }
    }
    输出结果：
    TomJerryTonyLucyHabi
    Tom,Jerry,Tony,Lucy,Habi
    <<Tom,Jerry,Tony,Lucy,Habi>>

注：参考文献：本篇文章主要参考并完善，希望对其他学习者有帮助。

[https://blog.csdn.net/u010572176/article/details/104425947][https_blog.csdn.net_u010572176_article_details_104425947]

[Java_JDK1.8_Optional]: https://blog.csdn.net/u010572176/article/details/104450282
[https_blog.csdn.net_u010572176_article_details_104425947]: https://blog.csdn.net/u010572176/article/details/104425947