java1.8Stream流（三）

终止操作

①匹配与查找

allMatch(Predicate p) -检查是否匹配所有元素。
anyMatch(Predicate p) -检查是否至少匹配一个元素。
noneMatch(Predicate p) -检查是否没有匹配的元素
findFirst -返回第一个元素
findAny -返回当前流中的任意元素
count -返回流中元素的总个数
max(Comparator c) -返回流中最大值
min(Comparator c) -返回流中最小值
forEach(Consumer c) -内部迭代

public class StreamAPITest2 {
    //1-匹配与查找
    @Test
    public void test1(){
//        allMatch(Predicate p) -检查是否匹配所有元素。
        //练习 是否所有员工的年龄大于18
        List<Employee> list=EmployeeData.getEmployees();
        boolean allMatch = list.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);
//        anyMatch(Predicate p) -检查是否至少匹配一个元素。
        //练习：是否有人工资大于10000
        boolean anyMatch = list.stream().anyMatch(employee -> employee.getSalary() > 10000);
        System.out.println(anyMatch);

//        noneMatch(Predicate p) -检查是否没有匹配的元素
        //练习：是否有人名字第一个字是"老"
        boolean noneMatch = list.stream().noneMatch(employee -> employee.getName().startsWith("老"));
        System.out.println(noneMatch);
//        findFirst -返回第一个元素
        Optional< Employee > first = list.stream().findFirst();
        System.out.println(first);
//        findAny -返回当前流中的任意元素
        Optional< Employee > any = list.parallelStream().findAny();
        System.out.println(any);


    }
    @Test
    public void test2(){
        List<Employee> list=EmployeeData.getEmployees();
        //        count -返回流中元素的总个数
        long count = list.stream().count();
        System.out.println(count);

//        max(Comparator c) -返回流中最大值
        //练习：返回最大工资
        Stream< Double > doubleStream = list.stream().map(employee -> employee.getSalary());
        Optional< Double > max = doubleStream.max(Double::compare);
        System.out.println(max);

//        min(Comparator c) -返回流中最小值
        //练习：返回最小工资
        Optional< Employee > min = list.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(min);
//        forEach(Consumer c) -内部迭代
}

②归约

reduce(T iden,BinaryOperator b) :可以将流中元素反复结合起来，得到一个值，返回T

reduce(BinaryOperator b) :可以将流中元素反复结合起来，得到一个值，返回一个Optional T 

//2.规约
@Test
public void test3(){
    //reduce(T iden,BinaryOperator b) :可以将流中元素反复结合起来，得到一个值，返回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 b) :可以将流中元素反复结合起来，得到一个值，返回一个Optional<T>
    //练习2：计算公司所有员工工资总和
    List<Employee> list1=EmployeeData.getEmployees();
    Stream< Double > stream = list1.stream().map(employee -> employee.getSalary());
    Optional< Double > reduce = stream.reduce((d1,d2)->d1+d2);
    System.out.println(reduce);

}

 ③收集

collect(Collector c) 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

public void test4(){
    //collect(Collector c) 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
    //练习：查找工资大于6000的员工，结果返回一个List或Set
    List< Employee > employees = EmployeeData.getEmployees();
    List< Employee > list = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
    list.forEach(System.out::println);

}