深入理解Java8新特性之Stream API的终止操作步骤

1.写在前面

承接了上一篇文章（说完了stream api的创建方式及中间操作）：深入理解java8新特性之stream api的创建方式和中间操作步骤。

我们都知道stream api完成的操作是需要三步的：创建stream → 中间操作 → 终止操作。那么这篇文章就来说一下终止操作。

2.终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：list、integer，甚至是 void 。

2.1 终止操作之查找与匹配

首先，我们仍然需要一个自定义的employee类，以及一个存储它的list集合。

在employee类定义了枚举（busy：忙碌；free：空闲；vocation：休假）

package com.szh.java8;
 
import lombok.allargsconstructor;
import lombok.data;
import lombok.noargsconstructor;
 
/**
 *
 */
@data
@noargsconstructor
@allargsconstructor
public class employee2 {
 
    private integer id;
    private string name;
    private integer age;
    private double salary;
    private status status;
 
    public employee2(integer id) {
        this.id = id;
    }
 
    public employee2(integer id, string name) {
        this.id = id;
        this.name = name;
    }
 
    public enum status {
        free,
        busy,
        vocation
    }
 
}

    list<employee2> employees = arrays.aslist(
            new employee2(1001,"张三",26,6666.66, employee2.status.busy),
            new employee2(1002,"李四",50,1111.11,employee2.status.free),
            new employee2(1003,"王五",18,9999.99,employee2.status.vocation),
            new employee2(1004,"赵六",35,8888.88,employee2.status.busy),
            new employee2(1005,"田七一",44,3333.33,employee2.status.free),
            new employee2(1005,"田七二",44,3333.33,employee2.status.vocation),
            new employee2(1005,"田七七",44,3333.33,employee2.status.busy)
    );

查找所有的员工是否都处于busy状态、至少有一个员工处于free状态、没有员工处于vocation状态。

    @test
    public void test1() {
        boolean b1 = employees.stream()
                .allmatch((e) -> e.getstatus().equals(employee2.status.busy));
        system.out.println(b1);
 
        boolean b2 = employees.stream()
                .anymatch((e) -> e.getstatus().equals(employee2.status.free));
        system.out.println(b2);
 
        boolean b3 = employees.stream()
                .nonematch((e) -> e.getstatus().equals(employee2.status.vocation));
        system.out.println(b3);
    }

对员工薪资进行排序之后，返回第一个员工的信息； 筛选出busy状态员工之后，返回任意一个处于busy状态的员工信息。

    @test
    public void test2() {
        optional<employee2> op1 = employees.stream()
                .sorted((e1, e2) -> double.compare(e1.getsalary(), e2.getsalary()))
                .findfirst();
        system.out.println(op1.get());
 
        system.out.println("----------------------------------");
 
        optional<employee2> op2 = employees.stream()
                .filter((e) -> e.getstatus().equals(employee2.status.busy))
                .findany();
        system.out.println(op2.get());
    }

下面，我们来看一下另外一组查找与匹配的方法。

计算处于vocation状态的员工数量；对员工薪资字段进行映射，同时获取其中的最高薪资；获取年龄最小的员工信息。

    @test
    public void test3() {
        long count = employees.stream()
                .filter((e) -> e.getstatus().equals(employee2.status.vocation))
                .count();
        system.out.println(count);
 
        optional<double> op1 = employees.stream()
                .map(employee2::getsalary)
                .max(double::compare);
        system.out.println(op1.get());
 
        optional<employee2> op2 = employees.stream()
                .min((e1, e2) -> integer.compare(e1.getage(), e2.getage()));
        system.out.println(op2.get());
    }

在这里，大家需要注意的一点就是：当前stream流一旦进行了终止操作，就不能再次使用了。

我们看下面的代码案例。（异常信息说的是：stream流已经被关闭了）

    @test
    public void test4() {
        stream<employee2> stream = employees.stream()
                .filter((e) -> e.getstatus().equals(employee2.status.busy));
        long count = stream.count();
 
        stream.map(employee2::getname);
    }

2.2 终止操作之归约与收集

collector 接口中方法的实现决定了如何对流执行收集操作 (如收集到 list、set、map) 。但是 collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：

计算整数1~10的和；对员工薪资字段进行映射，之后获取所有员工的薪资总和。

    @test
    public void test1() {
        list<integer> list = arrays.aslist(1,2,3,4,5,6,7,8,9,10);
        integer sum = list.stream()
                .reduce(0, (x, y) -> x + y);
        system.out.println(sum);
 
        system.out.println("-------------------------------");
 
        optional<double> optional = employees.stream()
                .map(employee2::getsalary)
                .reduce(double::sum);
        system.out.println(optional.get());
    }

依次对我们先前定义好的存储员工信息的list集合 做name字段的映射，然后 转为 list、set、hashset（使用 collectors 实用类中的静态方法即可完成）。

在set、hashset集合中，由于元素是无序、不可重复的，所以只有一个田七二。

    @test
    public void test2() {
        list<string> list = employees.stream()
                .map(employee2::getname)
                .collect(collectors.tolist());
        list.foreach(system.out::println);
 
        system.out.println("-------------------------------");
 
        set<string> set = employees.stream()
                .map(employee2::getname)
                .collect(collectors.toset());
        set.foreach(system.out::println);
 
        system.out.println("-------------------------------");
 
        hashset<string> hashset = employees.stream()
                .map(employee2::getname)
                .collect(collectors.tocollection(hashset::new));
        hashset.foreach(system.out::println);
    }

对员工薪资字段做映射，之后通过比较器获取最高薪资；

不做映射处理，直接通过比较器获取薪资最低的员工信息；

计算所有员工的薪资总和；

计算所有员工的平均薪资；

计算员工总数；

对员工薪资字段做映射，之后通过比较器获取最高薪资；

    @test
    public void test3() {
        optional<double> max = employees.stream()
                .map(employee2::getsalary)
                .collect(collectors.maxby(double::compare));
        system.out.println(max.get());
 
        optional<employee2> min = employees.stream()
                .collect(collectors.minby((e1, e2) -> double.compare(e1.getsalary(), e2.getsalary())));
        system.out.println(min.get());
 
        double sum = employees.stream()
                .collect(collectors.summingdouble(employee2::getsalary));
        system.out.println(sum);
 
        double avg = employees.stream()
                .collect(collectors.averagingdouble(employee2::getsalary));
        system.out.println(avg);
 
        long count = employees.stream()
                .collect(collectors.counting());
        system.out.println(count);
 
        doublesummarystatistics dss = employees.stream()
                .collect(collectors.summarizingdouble(employee2::getsalary));
        system.out.println(dss.getmax());
    }

单个条件分组：根据员工状态对stream流进行分组。 因为分组之后得到的是一个map集合，key就是员工状态，value则是一个list集合。

    @test
    public void test4() {
        map<employee2.status, list<employee2>> map = employees.stream()
                .collect(collectors.groupingby(employee2::getstatus));
 
        set<map.entry<employee2.status, list<employee2>>> set = map.entryset();
        iterator<map.entry<employee2.status, list<employee2>>> iterator = set.iterator();
        while (iterator.hasnext()) {
            map.entry<employee2.status, list<employee2>> entry = iterator.next();
            system.out.println(entry.getkey());
            system.out.println(entry.getvalue());
        }
    }

多个条件分组：先按照员工状态分组，如果状态相同，再按照员工年龄分组。

    @test
    public void test5() {
        map<employee2.status, map<string, list<employee2>>> map = employees.stream()
                .collect(collectors.groupingby(employee2::getstatus, collectors.groupingby((e) -> {
                    if (e.getage() <= 35) {
                        return "成年";
                    } else if (e.getage() <= 60) {
                        return "中年";
                    } else {
                        return "老年";
                    }
                })));
 
        set<employee2.status> set = map.keyset();
        iterator<employee2.status> iterator = set.iterator();
        while (iterator.hasnext()) {
            employee2.status next = iterator.next();
            map<string, list<employee2>> listmap = map.get(next);
            system.out.println(next);
            system.out.println(listmap);
        }
    }

根据特定的条件对员工进行分区处理。（员工薪资大于等于5000为 true 分区；否则都为 false 分区）。

    @test
    public void test6() {
        map<boolean, list<employee2>> map = employees.stream()
                .collect(collectors.partitioningby((e) -> e.getsalary() >= 5000));
        map.foreach((key,value) -> system.out.println("键：" + key + ", 值：" + value));
    }

以上就是深入理解java8新特性之stream api的终止操作步骤的详细内容，更多关于java8 stream api 终止操作的资料请关注其它相关文章！