java Stream常用api

 

public class TestSample {
    
    /**
     * stream生成
     */
    @Test
    public  void create() {

        //从参数产生
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
        Stream<Integer> integerStream2 = integerStream.sorted(Comparator.reverseOrder());
        //从数组产生
        Integer[] arr = { 6, 7, 8, 9, 10};
        Stream<Integer> integerStream1 = Stream.of(arr);
        //两个流的连接
        Stream.concat(integerStream2,integerStream1).forEach(System.out::println);
        //从生成器产生,参数是一个Supplier函数接口
        Stream.generate(() -> "echo")
                .limit(5)
                .distinct().forEach(System.out::println);
        Stream.generate(Math::random).limit(5).forEach(System.out::println);
        //从迭代器产生
        //以0作为种子，每次加1,跳过前11个数，从11开始，保留3个元素（11,12,13）
        Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE))
                .skip(11)
                .limit(3)
                .forEach(System.out::println);
        //以23年1月1日为种子，每次加一天，结束条件是年份不超过2023
        Stream.iterate(LocalDate.ofYearDay(2023, 1),
                        localDate -> localDate.getYear() == 2023,
                        localDate -> localDate.plusDays(1))
                .forEach(System.out::println);
    }

    @Test
    public void process(){
        Stream.generate(() -> "echo").limit(5)
                .map(String::toUpperCase)
                .peek(new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        int length = s.length();
                        System.out.println(length);
                    }
                })
                .forEach(System.out::println);


    }

    @Test
    public void reduce(){
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
        //流式加法
        Integer integer = integerStream.reduce((a,b)->a+b).orElse(0);
//        System.out.println(integer);
        Stream<Integer> integerStream1 = Stream.of(1, 2, 3, 4, 5);
        //流式乘法
        Integer reduce = integerStream1.reduce(1, (a, b) -> a * b);

        Stream<Integer> integerStream2 = Stream.of(1, 2, 3, 4, 5,6,7,8,9,10);
        //多线程加法,单个线程中计算使用第一个方法，各个线程的结果汇总时才会调用第二个方法
        Integer reduce1 = integerStream2
                .parallel()
                .reduce(0, new BiFunction<Integer, Integer, Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                int i = integer + integer2;
                System.out.format("f1:%d+%d=%d\n", integer, integer2, i);
                return i;
            }
        }, new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                int i = integer + integer2;
                System.out.format("f2:%d+%d=%d\n", integer, integer2, i);
                return i;
            }
        });
        System.out.println(reduce1);
        //结果类型与流类型不同，也可以用reducev3
        Stream<Integer> integerStream3 = Stream.of(1, 2, 3, 4, 5,6,7,8,9,10);
        HashSet<Integer> reduce2 = integerStream3.reduce(new HashSet<Integer>(),
                (set, item) -> {
            set.add(item);
            return set;
        }, (set1, set2) -> {
            set1.addAll(set2);
            return set1;
        });

        System.out.println(reduce2);
    }

    //分组聚合,简单约简
    @Test
    public void testGroup(){
        Integer[] arr = { 6, 7, 8, 9, 10};
        Random random = new Random();
        List<Model> modelStream = Stream
                .iterate(LocalDate.now(), localDate -> localDate.plusDays(1))
                .limit(10)
                .map(localDate -> new Model(localDate.toString(), random.nextDouble()))
                .collect(Collectors.toList());

        //以dt为key,num为value
        Map<String, Double> collect3 = modelStream.stream().collect(Collectors.toMap(Model::getDt, Model::getNum));
        System.out.println(collect3);
        //以dt为key,model本身为value
        Map<String, Model> collect = modelStream
                .stream()
                .collect(Collectors.toMap(Model::getDt, Function.identity()));
        System.out.println(collect);

        //遇到相同的key，如何处理，保留旧数据还是新数据
        Map<String, Double> collect4 = modelStream.stream().collect(Collectors.toMap(Model::getDt, Model::getNum, new BinaryOperator<Double>() {
            @Override
            public Double apply(Double oldData, Double newData) {
                return oldData;
            }
        }));

        Stream<Integer> integerStream = Stream.of(arr);
        //只有string才可以直接join，非string要先转成string
        String collect1 = integerStream.map(Object::toString).collect(Collectors.joining(","));
        System.out.println(collect1);

        //stream是一组规则集合，它不保存数据，消费完之后不可用二次消费
        //第一个
        Optional<Integer> first = Stream.of(arr).findFirst();
        System.out.println(first.get());
        Integer integer = first.orElse(0);
        //任意一个
        Optional<Integer> any = Stream.of(arr).findAny();
        System.out.println(any.get());
        //任意一个满足
        boolean b = Stream.of(arr).anyMatch(a -> a >= 5);
        System.out.println(b);
        //所有满足
        boolean b1 = Stream.of(arr).allMatch(a -> a > 5);
        System.out.println(b1);
        //没有一个满足
        boolean b2 = Stream.of(arr).noneMatch(a -> a > 5);
        System.out.println(b2);
        //计数
        long count = Stream.of(arr).count();
        //最大值
        Optional<Integer> max = Stream.of(arr).max(Integer::compareTo);
        System.out.println(max.get());
        //收集到treeSet中
        TreeSet<Integer> collect2 = Stream.of(arr).collect(Collectors.toCollection(TreeSet::new));


    }
}