Java流式编程的使用

流式编程的使用步骤

使用流式编程的步骤就是: 设置数据源, 设置数据处理的方式,设置收集结果的方式。

使用filter方法实现过滤条件

例子为下（查询年龄大于18的用户）:

    @Test
    public void streamTest1() {
        List<Student> students = Arrays.asList(
                new Student("tolen", 22, "男"),
                new Student("ostkakaw", 19, "女"),
                new Student("tolenaitolen", 18, "男")
        );

        List<Student> result = students
                .stream() //stream方法就是设置数据源
                .filter(user -> user.getAge() > 18) //设置过滤条件,这里的过滤条件使用lambda表达式
                .collect(Collectors.toList());//将结果设置为一个list
        for (Student student : result) {
            System.out.println(student.toString());
        }
    }

 结果为下：

特殊情况

 1. 限制条件存在多个且需要同时成立(且)

编写格式为下:

    @Test
    public void streamTest3() {
        List<Student> students = Arrays.asList(
                new Student("tolen", 22, "男"),
                new Student("ostkakaw", 19, "女"),
                new Student("tolenaitolen", 18, "男")
        );
        //编写限制条件
        Predicate<Student> predicate1 = user -> user.getAge() == 18;
        Predicate<Student> predicate2 = user -> user.getName() == "tolenaitolen";


        List<Student> result = students
                .stream() //stream方法就是设置数据源
                .filter(predicate1.and(predicate2)) //如果存在多个需要同时成立的条件时，需要使用and()方法
                .collect(Collectors.toList());//将结果设置为一个list
        for (Student student : result) {
            System.out.println(student.toString());
        }
    }

 结果为下:

2. 限制条件存在多个且不需要同时成立(或)

 编写格式为下：

    @Test
    public void streamTest4() {
        List<Student> students = Arrays.asList(
                new Student("tolen", 22, "男"),
                new Student("ostkakaw", 19, "女"),
                new Student("tolenaitolen", 18, "男")
        );
        //编写限制条件
        Predicate<Student> predicate1 = user -> user.getAge() > 18;
        Predicate<Student> predicate2 = user -> user.getName() == "tolen";

        List<Student> result = students
                .stream() //stream方法就是设置数据源
                .filter(predicate1.or(predicate2)) //如果存在多个需要同时成立的条件时，需要使用and()方法
                .collect(Collectors.toList());//将结果设置为一个list
        for (Student student : result) {
            System.out.println(student.toString());
        }
    }

结果为下:

使用limit方法限制list的长度

例子为下:

    @Test
    public void streamTest2() {
        List<Student> students = Arrays.asList(
                new Student("tolen", 22, "男"),
                new Student("ostkakaw", 19, "女"),
                new Student("tolenaitolen", 18, "男")
        );
        students
                .stream()//设置数据源
                .limit(2)//设置最大的长度
                .collect(Collectors.toList()) //将结果设置为一个list
                .forEach(student -> System.out.println(student.toString()));
    }

结果为下:

使用min和max方法找出最值

 例子为下:

    @Test
    public void streamTest5() {
        List<Integer> nums = Arrays.asList(4, 5, 1, 3, 6);
        Integer maxResult = nums.stream()//设置数据源
                .max(Integer::compareTo) //这里的lambda表达式使用Integer默认的比较方法,如果需要查询最小值就使用min方法
                .get();//max方法返回的数据是Optional,所以需要使用get方法才获得最终的数据
        System.out.println(maxResult);
    }

结果为下:

如果需要查询最小值的话，我们只需要将max方法换成min方法即可。

使用sorted方法对list进行排序

 例子为下:

    @Test
    public void streamTest6() {
        List<Integer> nums = Arrays.asList(4, 5, 1, 3, 6);
        nums.stream() //设置数据源
                .sorted(Integer::compareTo) //进行排序操作，默认使用升序
                .collect(Collectors.toList()).forEach(num -> System.out.println(num));
    }

结果为下:

特殊情况

 需要实现降序，对应的代格式为下:

    @Test
    public void streamTest6() {
        List<Integer> nums = Arrays.asList(4, 5, 1, 3, 6);
        nums.stream() //设置数据源
                .sorted(Comparator.reverseOrder()) //进行排序操作，默认使用升序,lambda表达式设置为降序
                .collect(Collectors.toList()).forEach(num -> System.out.println(num));
    }

结果为下:

使用map方法和reduce方法对应list的数据进行修改

map方法(返回的结果是多个，而非只有一个，用于返回一个完整的list)

例子为下:

    @Test
    public void streamTest7() {
        List<Integer> nums = Arrays.asList(4, 5, 1, 3, 6);
        nums.stream() //设置数据源
                .map(num -> num + 10)
                .collect(Collectors.toList())
                .forEach(num -> System.out.println(num));
    }

效果为下:

reduce方法(返回的结果只有一个，用于做累计操作)

例子为下:

    @Test
    public void streamTest8() {
        List<Integer> nums = Arrays.asList(4, 5, 1, 3, 6);
        Integer result = nums.stream() //设置数据源
                .reduce((num, sum) -> num + sum) //等于做累加操作,在lambda表达式中的参数 num 和sum 的位置可以互换，不影响累加的结果
                .get();
        System.out.println(result);
    }

 结果为下:

等于做累加操作,在lambda表达式中的参数 num 和sum 的位置可以互换，不影响累加的结果。

使用count方法计算list的长度

例子为下:

    @Test
    public void streamTest9() {
        List<Integer> nums = Arrays.asList(4, 5, 1, 3, 6);
        long count = nums.stream() //设置数据源
                .count();
        System.out.println(count);
    }

效果为下：

使用flatMap方法对数据进行压扁

例子:

例子中通过map会获得对应的数组,通过flatMap方法将这些数组压扁为流。（便于后续操作）

 作用:将数组转换为流。