Java中Stream

用法:
直接上代码

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.util.*;
import java.util.function.BinaryOperator;
import java.util.stream.Stream;

/**
 * Created by macro on 2022/3/19
 *
 * @author hhoa
 **/
public class TestStream {
    private List<Double> doubleList;
    private List<Integer> integerList;
    private List<String> stringList;
    /**
     * 返回此流中的所有元素是否匹配所提供的谓词。
     */
    @DisplayName("测试AllMatch的作用")
    @Test
    public void testAllMatch(){
        Stream<Integer> integerStream = integerList.stream();
        boolean b = integerStream.allMatch((e) -> e == 1);
        System.out.println("是否都等于1:"+ b);

        integerStream = integerList.stream();
        boolean b1 = integerStream.allMatch((e) -> e > 0);
        System.out.println("是否都大于0:"+b1);
    }

    /**
     * 流中只要有一个匹配就返回true，否则返回false
     */
    @DisplayName("测试AnyMath")
    @Test
    public void testAnyMath(){
        Stream<Integer> integerStream = integerList.stream();
        boolean b = integerStream.anyMatch((e) -> e == 1);
        System.out.println("是有一个等于1:"+ b);

        integerStream = integerList.stream();
        boolean b1 = integerStream.anyMatch((e) -> e > 0);
        System.out.println("是有一个大于0:"+b1);
    }

    /**
     * 连接两个流
     */
    @DisplayName("测试Concat")
    @Test
    public void testConcat(){
        Stream<Integer> integerStream = integerList.stream();
        Stream<Integer> integerStream1 = integerList.stream();
        Stream<Integer> concat = Stream.concat(integerStream, integerStream1);
        List<Integer> integers = concat.toList();
        System.out.println(integers);
    }

    /**
     * 获取流中元素个数
     */
    @DisplayName("测试count")
    @Test
    public void testCount(){
        Stream<Integer> stream = integerList.stream();
        long count = stream.count();
        System.out.println(count);
    }

    /**
     * 获取不含重复元素的流
     */
    @DisplayName("测试distinct")
    @Test
    public void testDistinct(){
        Stream<Integer> stream = integerList.stream();
        Stream<Integer> distinct = stream.distinct();
        List<Integer> integers = distinct.toList();
        System.out.println(integers);
    }

    /**
     * 根据Predicate进行过滤,test返回false则过滤,
     */
    @DisplayName("测试Filter")
    @Test
    public void testFilter(){
        Stream<Integer> stream = integerList.stream();
        Stream<Integer> integerStream = stream.filter((t) -> t > 5);
        List<Integer> integers = integerStream.toList();
        System.out.println(integers);
    }

    /**
     * 只要有值则返回该值
     */
    @DisplayName("测试findAny")
    @Test
    public void testFindAny(){
        Stream<Integer> stream = integerList.stream();
        Optional<Integer> any = stream.findAny();
        System.out.println(any.orElse(null));
    }

    /**
     * 返回第一个数
     */
    @DisplayName("测试findFirst")
    @Test
    public void testFindFirst(){
        Stream<Integer> stream = integerList.stream();
        Optional<Integer> any = stream.findFirst();
        System.out.println(any.orElse(null));
    }
    /**
     * 返回由将所提供的映射函数应用到每个元素的映射流的内容替换此流的每个元素的结果的结果流。
     * 同理还有flatMaoToDouble, flatMapToInt, flatMapToLong
     */
    @DisplayName("测试findFlatMap")
    @Test
    public void testFlatMap(){
        Stream<String> stream = stringList.stream();
        Stream<String> stringStream = stream.flatMap((t)->Stream.of("[" +t+"]"));
        System.out.println(stringStream.toList());
    }

    /**
     * 遍历每个元素并执行操作
     * 操作由自定义Consumer里面的accept来定
     * forEachOrdered:按顺序执行操作
     */
    @DisplayName("测试ForEach")
    @Test
    public void testForEach(){
        Stream<Integer> stream = integerList.stream();
        stream.forEach((t)-> System.out.print(t));
        System.out.println();
        //替换为
        stream = integerList.stream();
        stream.forEach(System.out::print);
        System.out.println();
        //还有一个forEachOrder
        stream = integerList.stream();
        stream.forEachOrdered(System.out::print);
        System.out.println();
    }

    /**
     * 返回一个无穷无序流，里面的数由Supplier的get函数提供，该函数需要我们实现
     */
    @DisplayName("测试Generate")
    @Test
    public void testGenerate(){
        Stream<Integer> generate = Stream.generate(() -> new Random().nextInt());
        System.out.println(generate.limit(4).toList());
    }

    /**
     * 返回一个无穷有序流，我们需要提供一个种子，该种子被UnaryOperator一直调用identity返回流数据，
     * 函数identity可以重写，也可以不用重写，
     */
    @DisplayName("测试Iterate")
    @Test
    public void testIterate(){
        Stream<Integer> generate = Stream.iterate(1, (t)->++t);
        System.out.println(generate.limit(4).toList());
    }

    /**
     * 截取流中不超过maxSize个元素
     */
    @DisplayName("测试limit")
    @Test
    public void testLimit(){
        Stream<Integer> stream = integerList.stream();
        Stream<Integer> limit = stream.limit(3);
        System.out.println(limit.toList());

    }

    /**
     * 返回一个流，流中元素为自定义Function对每个原来流元素执行Apply的结果
     *
     * 类似: mapToInt, mapToDouble, mapToLong
     * 将流内元素映射为Int、Double、Long型
     */
    @DisplayName("测试map")
    @Test
    public void testMap(){
        Stream<Integer> stream = integerList.stream();
        Stream<Integer> integerStream = stream.map((t) -> t * 2);
        System.out.println(integerStream.toList());
    }

    /**
     * 获取最大最小值的Optional
     * 需要传入Comparator比较器
     */
    @DisplayName("测试MaxMin")
    @Test
    public void testMaxMin(){
        Stream<Integer> stream = integerList.stream();
        System.out.println(stream.max(Comparator.comparingInt(a -> a)));
        stream = integerList.stream();
        System.out.println(stream.min(Comparator.comparingInt(a -> a)));
    }

    /**
     * 返回此流中的任何元素是否不匹配所提供的Predicate。
     */
    @DisplayName("测试NoneMatch")
    @Test
    public void testNoneMatch(){
        Stream<Integer> stream = integerList.stream();
        boolean b = stream.noneMatch((t) -> t > 7);
        System.out.println(b);
    }

    /**
     * 返回此包含指定元素的流
     */
    @DisplayName("测试Of")
    @Test
    public void testOf(){
        System.out.println(Stream.of(1).toList());
        System.out.println(Stream.of(1,2,3).toList());
    }

    /**
     * 返回由该流的元素组成的流，并在所提供的流中执行Consumer所提供的每个元素上的动作。
     * 类似map
     */
    @DisplayName("测试peek")
    @Test
    public void testPeek(){
        Stream<Integer> stream = integerList.stream();
        Stream<Integer> peek = stream.peek((t)->t*=2);
        System.out.println(peek.toList());
    }

    /**
     *  类似max, min
     */
    @DisplayName("测试reduce")
    @Test
    public void testReduce(){
        Stream<Integer> stream = integerList.stream();
        Optional<Integer> reduce = stream.reduce(BinaryOperator.maxBy(Comparator.comparingInt(a->a)));
        System.out.println(reduce.orElse(null));
    }

    /**
     *  丢弃n个元素
     */
    @DisplayName("测试Skip")
    @Test
    public void testSkip(){
        Stream<Integer> stream = integerList.stream();
        System.out.println(stream.skip(3).toList());
    }
    /**
     *  排序
     */
    @DisplayName("测试Sorted")
    @Test
    public void testSorted(){
        Stream<Integer> stream = integerList.stream();
        System.out.println(stream.sorted().toList());
        stream = integerList.stream();
        System.out.println(stream.sorted((a,b)->b-a).toList());
    }

    /**
     * 返回流元素数组
     */
    @Test
    public void testToArray(){
        Stream<Integer> stream = integerList.stream();
        Object[] objects = stream.toArray();
        for (Object o : objects){
            System.out.println(o);
        }
    }
    @DisplayName("----------------------------------分界线-------------------------------------------------")
    @BeforeEach
    public void getStringList(){
        List<String> list = Arrays.asList("zhangsan", "lisi", "wangwu");
        System.out.print("字符串数组:[");
        this.stringList = list;
        for (String str: list){
            System.out.print(str+ " ");
        }
        System.out.print("]\n");
    }

    @BeforeEach
    public void getIntegerList(){
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 4; i++){
            int num = Math.abs(new Random().nextInt() % 10);
            list.add(num);
            System.out.print(num+ "  ");
        }
        this.integerList = list;
        System.out.println();
    }
    @BeforeEach
    public void getDoubleList(){
        List<Double> list = new ArrayList<>();
        for (int i = 0; i < 4; i++){
            double num = Math.abs(new Random().nextDouble() % 10);
            list.add(num);
            System.out.print(num+ "  ");
        }
        this.doubleList = list;
        System.out.println();
    }
}