Stream的终止操作1：匹配与查找

public class test {

    //匹配与查找
    @Test
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();
        //allMatch(Predicate p) 检查是否匹配所有元素,所有的都是true结果才为true

        //例子：是否所有员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);//得到的stream操作的是集合中的Employee，allMatch中断定型的传进来的是Employee
        System.out.println(allMatch);//false

        //anyMatch(Predicate p) 检查是否至少匹配一个元素,只要有一个符合就是true
        //例子：是否存在员工的工资大于10000
        boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
        System.out.println(anyMatch);//false

        //noneMatch(Predicate p) 检查是否没有匹配所有元素(注意不是检查是否有)
        //例子：是否有员工姓雷
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(noneMatch);//false

        //findFirst() 返回第一个元素(如果不进行其他操作就是List中放的第一个元素),可以在之前加上一些其他的中间操作，比如排序
        Optional<Employee> employee = employees.stream().findFirst();//返回的类型是Optional，是容器，处理空指针问题的时候使用
        System.out.println(employee);//Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}]


        //findAny() 返回当前流中的任意元素
        Optional<Employee> employee1 = employees.stream().findAny();
        System.out.println(employee1);//输出的结果都是这个，Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}]

        //因为与Stream有关，Stream是顺序流，所以findAny总是从第一个去取。
        // 我们调用的是Stream的方法，但如果换成parallelStream
        Optional<Employee> employee2 = employees.parallelStream().findAny();
        System.out.println(employee2);//Optional[Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}]


        //count() 返回流中元素总数,count之前可以进行过滤操作,过滤操作完成之后返回的仍然是employee构成的Stream
        //员工工资大于5000的个数
        long count = employees.stream().filter(e->e.getSalary()>5000).count();
        System.out.println(count);//5，所以工资高于5000的有5个人

        //max(Comparator c) 返回流中最大值
        //例子：返回最高的工资
        Optional<Double> maxSalary = employees.stream().map(e -> e.getSalary()).max((o1, o2) -> Double.compare(o1, o2));
        System.out.println(maxSalary);//Optional[9876.12]


        //min(Comparator c) 返回流中最小值
        //例子：返回最低工资的员工
        Optional<Employee> employee3 = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(employee3);//Optional[Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}]

        System.out.println();

        //forEach(Consumer c)内部迭代
        //Iterator是外部迭代
        employees.stream().forEach(System.out::println);//这种遍历方式叫做内部迭代，即stream调用forEach进行的迭代操作

        System.out.println();

        //注意:集合中也有forEach,也是遍历操作，但是和上面的主体不一样，这里是集合中的default方法
        employees.forEach(System.out::println);

    }

}

输出结果为：

false
false
false
Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}]
Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}]
Optional[Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}]
5
Optional[9876.12]
Optional[Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}]

Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1007, name='任正非', age=26, salary=4333.32}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}

Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1007, name='任正非', age=26, salary=4333.32}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}