stream查找与匹配(终止操作)——Java8新特性

package com.example.demo.lambdaStreamAPI;

import com.example.demo.lambda.Employee;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

/**
 * @Description stream api
 * stream api 的操作步骤：
 *      1. 创建stream
 *      2. 中间操作
 *      3. 终止操作（终端操作）
 *
 * @Auther gf.x
 * @Date 2020/3/24 16:35
 */
public class StreamAPITest2 {

    //三. 终止操作
    /**
     * 查找与匹配：
     * allMatch：检查是否匹配所有元素
     * anyMatch：检查是否至少匹配一个元素
     * noneMatch：检查是否没有匹配的元素
     * findFirst：返回第一个元素
     * findAny：返回当前流中的任意元素
     * count：返回流中元素的总个数
     * max：返回流中最大值
     * min：返回流中最小值
     */

    List<Employee> emps = Arrays.asList(
            new Employee("李四", 59, 6666.66, Employee.Status.BUSY),
            new Employee("张三", 18, 9999.99, Employee.Status.FREE),
            new Employee("王五", 28, 3333.33, Employee.Status.VOCATION),
            new Employee("赵六", 8, 7777.77, Employee.Status.BUSY),
            new Employee("赵六", 8, 7777.77, Employee.Status.FREE),
            new Employee("赵六", 8, 7777.77, Employee.Status.FREE),
            new Employee("田七", 38, 5555.55, Employee.Status.BUSY)
    );

    @Test
    public void test() {
        boolean b = emps.stream()
                .allMatch(e -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(b);

        boolean b1 = emps.stream()
                .anyMatch(e -> e.getStatus().equals(Employee.Status.FREE));
        System.out.println(b1);

        boolean b2 = emps.stream()
                .noneMatch(e -> e.getStatus().equals(Employee.Status.VOCATION));
        System.out.println(b2);

        //不排序(不进行中间操作，直接执行终止操作)，直接获取原顺序中的第一个员工信息
        Optional<Employee> first1 = emps.stream()
                .findFirst();
        System.out.println(first1.get());

        //员工按照工资排序(从小到大：中间操作)，然后获取第一个员工信息
        Optional<Employee> first = emps.stream()
                .sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
                .findFirst();
        System.out.println(first.get());

        //串行流
        //先过滤出状态是FREE的所有员工(中间操作：返回stream)，然后在其中任意找出一个(终止操作：返回Optional<Employee>)
        //串行流 是单线程按顺序挨个(过滤、查找)
        Optional<Employee> any = emps.stream()
                .filter(e -> e.getStatus().equals(Employee.Status.FREE))
                .findAny();
        System.out.println(any.get());

        //并行流
        //并行流 是多线程同时分别(过滤、查找)
        Optional<Employee> any1 = emps.parallelStream()
                .filter(e -> e.getStatus().equals(Employee.Status.FREE))
                .findAny();
        System.out.println(any1);
    }

    @Test
    public void test2() {
        long count = emps.stream()
                .count();
        System.out.println(count);

        Optional<Employee> max = emps.stream()
                .max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(max.get());

        Optional<Double> min = emps.stream()
                .map(Employee::getSalary)
                .min(Double::compare);
        System.out.println(min.get());
    }
}