jdk1.8新特性的应用-Stream Api

/**
 * Created by IntelliJ Idea 2018.1
 * Author:Gavin Zhang
 * Data:  2021-07-29
 * Time:  22:06
 */
public class TestStreamApi1 {
    public static void main(String[] args) {
        /*
        * 一.Stream 的三个操作步骤
        * 1.创建 Stream
        * 2.中间操作
        * 3.终止操作(终端操作)
        * */

        //1. 可以通过Collection 系列提供的stream() 或parallelStream()
        ArrayList<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        //2. 通过Arrays中的静态方法stream()获得数组流
        Employee[] employees = new Employee[10];
        Stream<Employee> stream2 = Arrays.stream(employees);

        //3. 通过Stream 中的 of()
        Stream<String> stream3 = Stream.of("aa", "bb", "cc");

        //4. 创建无限流
        //迭代
        Stream<Integer> stream4 = Stream.iterate(0, x -> x + 2);
        stream4.limit(10).forEach(System.out::println);

        //生成
        Stream.generate(()->Math.random())
                .limit(5)
                .forEach(System.out::println);
    }

/**
 * Created by IntelliJ Idea 2018.1
 * Author:Gavin Zhang
 * Data:  2021-07-29
 * Time:  22:33
 */
public class TestStreamApi2 {
    public static void main(String[] args) {
        List<Employee> emps = Arrays.asList(
                new Employee("张三", 23, 14000.11, "深圳"),
                new Employee("李四", 34, 26000.33, "北京"),
                new Employee("王五", 55, 18000.00, "上海"),
                new Employee("赵六", 32, 22000.88, "广州"),
                new Employee("田七", 23, 14000.11, "深圳")
        );
        //1.筛选与过滤(筛选出年龄大于30的员工)
        Stream<Employee> employeeStream = emps.stream().filter((e) -> e.getAge() > 30);
        List<Employee> employeeList = employeeStream.collect(Collectors.toList());
        System.out.println("employeeList = " + employeeList); //李四 王五  赵六

        //筛选与过滤(筛选出薪资大于15000的员工并且取前2条)
        Stream<Employee> employeeStream2 = emps.stream().filter((e) -> e.getSalary() > 15000).limit(2);
        List<Employee> employeeList2 = employeeStream2.collect(Collectors.toList());
        System.out.println("employeeList2 = " + employeeList2); //李四 王五

        //筛选与过滤(筛选出薪资大于15000的员工并且跳过前2条)
        Stream<Employee> employeeStream3 = emps.stream().filter((e) -> e.getSalary() > 15000).skip(2);
        List<Employee> employeeList3 = employeeStream3.collect(Collectors.toList());
        System.out.println("employeeList3 = " + employeeList3);//赵六
    }
     /*中间操作*/
    /*
     * 排序
     * sorted-自然排序(Comparable)
     * sorted(Comparator com)--定制排序(Comparator)
     * */
    @Test
    public void test1(){
        List<String> list = Arrays.asList("ddd", "bbb", "ccc", "aaa", "bbb");
        //自然排序
        Stream<String> sorted = list.stream().sorted();
        sorted.forEach(System.out::println);

        //list转set
        Set<String> set = new HashSet<>(list);
        System.out.println("set = " + set);//set = [aaa, ccc, bbb, ddd]

        Set<String> set2 = list.stream().collect(Collectors.toSet());
        System.out.println("set2 = " + set2);//set2 = [aaa, ccc, bbb, ddd]

        //定制排序
        emps.stream()
                .sorted((e1, e2) -> {
                    if (e1.getAge() == e2.getAge()) {
                        return e1.getName().compareTo(e2.getName());
                    }else {
                        return String.valueOf(e1.getAge()).compareTo(String.valueOf(e2.getAge()));
                    }
                }).forEach(System.out::println);
    }
}

public class TestStreamApi3 {
    List<Employee> emps = Arrays.asList(
            new Employee("张三", 23, 14000.11, "深圳"),
            new Employee("李四", 34, 26000.33, "北京"),
            new Employee("王五", 55, 18000.00, "上海"),
            new Employee("赵六", 32, 22000.88, "广州"),
            new Employee("田七", 23, 14000.11, "深圳")
    );

    /*
     * 查找与匹配
     * */
    @Test
    public void test1() {
        //allMatch--检查是否匹配所有元素
        //查找员工是否都在北京
        boolean allMatch = emps.stream().allMatch(e -> e.getAddress().equals("北京"));
        System.out.println("allMatch = " + allMatch);//allMatch = false

    }

    @Test
    public void test2() {
        //anyMatch--检查是否至少匹配一个元素
        //检查员工是不是至少有一个人在上海
        boolean anyMatch = emps.stream().anyMatch(e -> e.getAddress().equals("上海"));
        System.out.println("anyMatch = " + anyMatch);//anyMatch = true

    }

    @Test
    public void test3() {
        //noneMatch--检查是否没有匹配所有元素(至少匹配到一个返回false 双重否定)
        boolean noneMatch = emps.stream().noneMatch(e -> e.getAddress().equals("上海"));
        System.out.println("noneMatch = " + noneMatch);//noneMatch = false
    }

    @Test
    public void test4() {
        //findFirst--返回第一个元素
        //查询员工工资最高的员工信息
        Optional<Employee> op = emps.stream().sorted((e1, e2) -> -Double.compare(e1.getSalary(), e2.getSalary()))
                .findFirst();
        Employee employee = op.get();
        System.out.println(employee);
        //Employee{name='李四', age=34, salary=26000.33, address='北京'}
    }

    @Test
    public void test5() {
        //findAny--返回当前流中的任意元素
        //查找员工有没有地址是郑州的?   stream()--串行流(单线程)
        Optional<Employee> findAny = emps.stream().filter(e -> e.getAddress().equals("深圳")).findAny();
        System.out.println(findAny.get());
        //Employee{name='张三', age=23, salary=14000.11, address='深圳'}

        //parallelStream()--并行流(多线程)
        Optional<Employee> findAny2 = emps.parallelStream().filter(e -> e.getAddress().equals("深圳")).findAny();
        System.out.println(findAny2.get());
        //Employee{name='田七', age=23, salary=14000.11, address='深圳'}
    }

    @Test
    public void test6() {
        //count--返回流中元素的总个数
        long count = emps.stream().count();
        System.out.println("count = " + count);
        //5

        //max--返回流中最大值
        //获取员工工资最多的员工信息
        Optional<Employee> max = emps.parallelStream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(max.get());
        //Employee{name='李四', age=34, salary=26000.33, address='北京'}

        //获取员工工资最少的员工信息
        Optional<Employee> min = emps.parallelStream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(min.get());
        //Employee{name='张三', age=23, salary=14000.11, address='深圳'}

    }
}

@Test
    public void test7() {
        /*
        * 归约:可以将流中元素反复结合起来,得到一个值
        * */
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer reduce = list.stream().reduce(0, (x, y) -> x + y);//0为初始值
        System.out.println("reduce = " + reduce);//reduce = 55

        Optional<Double> reduce1 = emps.stream()
                .map(employee -> employee.getSalary())
                .reduce(Double::sum);
        Double aDouble = reduce1.get();
        System.out.println("aDouble = " + aDouble);
        //aDouble = 94001.43000000001
    }