5-常用流的中间操作和终端操作

常用流的中间操作

filter使用:过滤掉不符合断言判断的数据

map使用:将一个元素转换成另一个元素

flatMap使用:将一个对象转换成流

peek使用:遍历操作

sorted使用:排序

distinct使用:去重

skip使用:跳过前几条

limit使用:取限制条数数据

常用流的终端操作

allMatch使用:所有元素匹配返回true

anyMatch使用:任何元素匹配返回true

noneMatch使用:任何元素都不匹配返回true

findFirst使用:找到第一个

findAny使用:找到任意一个

max使用:获取最大值

min使用:获取最小值

count使用:获取集合个数

import com.alibaba.fastjson.JSON;
import org.junit.Before;
import org.junit.Test;

import java.util.*;

/**
 * @description: 演示流的各种操作
 */
public class StreamOperator {

    static class Student{
        private String name;
        private Integer age;

        Student(String name, Integer age){
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public Integer getAge() {
            return age;
        }

        public void setAge(Integer age) {
            this.age = age;
        }
    }

    List<Student> list;

    @Before
    public void init(){
        /**
         * 该写法有内存泄漏风险,不要在生产使用
         */
        list = new ArrayList<Student>(){
            {
                add(new Student("小明", 22));
                add(new Student("小黄", 20));
                add(new Student("小红", 21));
                add(new Student("小超", 25));
                add(new Student("小王", 20));
            }
        };
    }

    /**
     * filter使用:过滤掉不符合断言判断的数据
     */
    @Test
    public void filterTest(){
        list.stream()
                .filter(student -> student.getAge() > 20)
                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(item, true)
                        ));
        //{
        //    "age":22,
        //    "name":"小明"
        //}
        //{
        //    "age":21,
        //    "name":"小红"
        //}
        //{
        //    "age":25,
        //    "name":"小超"
        //}
    }

    /**
     * 将一个元素转换成另一个元素
     */
    @Test
    public void mapTest(){
        list.stream()
                .map(student -> student.getName())
                .forEach(item ->
                        System.out.print(
                                JSON.toJSONString(item, true)
                        ));
        //"小明""小黄""小红""小超""小王"
    }

    /**
     * flatMap使用:将一个对象转换成流
     */
    @Test
    public void flatMapTest(){
        list.stream()
                .flatMap(student -> Arrays.stream(
                        student.getName().split("")
                ))
                .forEach(item ->
                        System.out.print(
                                JSON.toJSONString(item, true)
                        ));
        //"小""明""小""黄""小""红""小""超""小""王"
    }

    /**
     * peek使用:遍历操作
     * 注意:此时peek和forEach是交替打印的
     */
    @Test
    public void peekTest(){
        list.stream()
                .peek(student -> System.out.println(student.getName()))
                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(item, true)
                        ));
        //小明
        //{
        //    "age":22,
        //    "name":"小明"
        //}
        //小黄
        //{
        //    "age":20,
        //    "name":"小黄"
        //}
        //小红
        //{
        //    "age":21,
        //    "name":"小红"
        //}
        //小超
        //{
        //    "age":25,
        //    "name":"小超"
        //}
        //小王
        //{
        //    "age":20,
        //    "name":"小王"
        //}
    }

    /**
     * sorted使用:排序
     * 注意:添加有状态的sorted操作后,peek和forEach分开打印
     */
    @Test
    public void sortTest(){
        list.stream()
                .peek(student -> System.out.println(student.getName()))
                .sorted(Comparator.comparing(Student::getAge).reversed())
                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(item, true)
                        ));
        //小明
        //小黄
        //小红
        //小超
        //小王
        //{
        //    "age":20,
        //    "name":"小黄"
        //}
        //{
        //    "age":20,
        //    "name":"小王"
        //}
        //{
        //    "age":21,
        //    "name":"小红"
        //}
        //{
        //    "age":22,
        //    "name":"小明"
        //}
        //{
        //    "age":25,
        //    "name":"小超"
        //}
    }

    /**
     * distinct使用:去重
     */
    @Test
    public void distinctTest(){
        list.stream()
                .map(student -> student.getAge())
                .distinct()
                .forEach(item ->
                        System.out.print(
                                JSON.toJSONString(item, true) + " "
                        ));
        //22 20 21 25
    }

    /**
     * skip使用:跳过前几条
     */
    @Test
    public void skipTest(){
        list.stream()
                .sorted(Comparator.comparing(Student::getAge))
                .skip(2)
                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(item, true)
                        ));
        //{
        //    "age":21,
        //    "name":"小红"
        //}
        //{
        //    "age":22,
        //    "name":"小明"
        //}
        //{
        //    "age":25,
        //    "name":"小超"
        //}
    }

    /**
     * limit使用:取限制条数数据
     * skip和limit可以实现伪分页
     */
    @Test
    public void limitTest(){
        list.stream()
                .sorted(Comparator.comparing(Student::getAge))
                .limit(3)
                .forEach(item ->
                        System.out.println(
                                JSON.toJSONString(item, true)
                        ));
        //{
        //    "age":20,
        //    "name":"小黄"
        //}
        //{
        //    "age":20,
        //    "name":"小王"
        //}
        //{
        //    "age":21,
        //    "name":"小红"
        //}
    }

    /**
     * allMatch使用:所有元素匹配返回true
     * 终端操作,短路操作,只要不满足就立刻返回
     */
    @Test
    public void allMatchTest() {
        boolean match = list.stream()
                .peek(student -> System.out.println(student.getName()))
                .allMatch(student -> student.getAge() > 20);
        System.out.println(match);
        //小明
        //小黄
        //false
    }

    /**
     * anyMatch使用:任何元素匹配返回true
     * 终端操作,短路操作,只要满足就立刻返回
     */
    @Test
    public void anyMatchTest() {
        boolean match = list.stream()
                .peek(student -> System.out.println(student.getName()))
                .anyMatch(student -> student.getAge() > 20);
        System.out.println(match);
        //小明
        //true
    }

    /**
     * noneMatch使用:任何元素都不匹配返回true
     */
    @Test
    public void noneMatchTest() {
        boolean match = list.stream()
                .peek(student -> System.out.println(student.getName()))
                .noneMatch(student -> student.getAge() > 20);
        System.out.println(match);
        //小明
        //false
    }

    /**
     * findFirst使用:找到第一个
     */
    @Test
    public void findFirstTest(){
        Optional<Student> optional = list.stream()
                .findFirst();
        System.out.println(JSON.toJSONString(optional.get(), true));
        //{
        //    "age":22,
        //    "name":"小明"
        //}
    }

    /**
     * findAny使用:找到任意一个
     */
    @Test
    public void findAnyTest(){
        Optional<Student> optional = list.stream()
                .findAny();
        System.out.println(JSON.toJSONString(optional.get(), true));
        //{
        //    "age":22,
        //    "name":"小明"
        //}
    }

    /**
     * max使用:获取最大值
     */
    @Test
    public void maxTest(){
        OptionalInt optionalInt = list.stream()
                .mapToInt(Student::getAge)
                .max();
        System.out.println(optionalInt.getAsInt());
        //25
    }

    /**
     * min使用:获取最小值
     */
    @Test
    public void minTest(){
        OptionalInt optionalInt = list.stream()
                .mapToInt(Student::getAge)
                .min();
        System.out.println(optionalInt.getAsInt());
        //20
    }

    /**
     * count使用:获取集合个数
     */
    @Test
    public void countTest(){
        long count = list.stream()
                .count();
        System.out.println(count);
        //5
    }
}