java8新特性——Stream

一.stream介绍

stream(流)是一个来自数据源的元素队列

集合讲的是数据，而流讲的是计算

注意：

①stream自己不会存储元素

②stream不会改变源对象，相反他会返回一个持有结果的新stream

③stream操作是延时执行的，这意味着他们会等到需要结果的时候才执行

stream操作的三个步骤

①创建stream

　　　　//1.通过Collection 系列集合提供的stream()[串行流]或 [并行流]来生成流
        List list = new ArrayList();
        Stream stream = list.stream();

        //2.通过Arrays中的静态方法stream()获取数据流
        String[] arr = new String[10];
        Stream<String> stream1 = Arrays.stream(arr);

        //3.通过Stream类中的静态方法of()
        Stream<String> aa = Stream.of("aa", "bb", "cc");//4.创建无限流
        //迭代
        Stream<Integer> iterate = Stream.iterate(0, (x) -> x + 2);//生成
        Stream.generate(() -> Math.random());

②中间操作

        List list = List.of("aa","bb","cc","aa");
        //1.filter 排除某些元素
        // 将内容为"aa"的元素排除
        list.stream().filter( (str)-> !str.equals("aa")).forEach(System.out::println);

        //2.limit 截断流，使其元素不超过给定数量
        // 取两个元素
        list.stream().limit(2).forEach(System.out::println);

        //3.skip 跳过元素，返回一个扔掉了前n个元素的流
        // 跳过两个元素
        list.stream().skip(2).forEach(System.out::println);

        //4.distinct 筛选，通过流生成元素的hashCode()和equals()去除重复元素
        list.stream().distinct().forEach(System.out::println);

        //5.map 映射，将元素转换成其他形式或提取信息。接受一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
        //将流中的元素全部转换成大写
        Stream<String> string = list.stream();
        string.map((str) -> str.toUpperCase()).forEach(System.out::println);

        //6.flatMap  接受一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
        List<List<String>> list02 = new ArrayList();
        list02.add(list);
        list02.add(list);
        /**
         *  现在list里的数据为[ ["aa","bb","cc","aa"],["aa","bb","cc","aa"] ]
         *  如果用map映射的话 stream流里的结构是 { {"aa","bb","cc","aa"},{"aa","bb","cc","aa"} }的
         *  如果用flatmap映射的话 stream流里的结构就是 {"aa","bb","cc","aa","aa","bb","cc","aa" }的
         */
        Stream<List<String>> stringStream = list02.stream();
        stringStream.map((lst) -> lst.stream().map((str) -> str.toUpperCase()));

        /**
         * 7.排序
         * sorted()  自然排序,就是用Comparable的方式取排
         * sorted(Comparator com)  自定义排序
         */
         //自然排序
         List list03 = List.of("hh","b","cccc","aaa");
         list03.stream().sorted().forEach(System.out::println);
         //结果： aaa  b  cccc  hh

         //自定义按照长度排序
         Stream<String> stringStream1 = list03.stream();
         stringStream1.sorted((str1,str2) -> str2.length()-str1.length()).forEach(System.out::println);
         //结果: cccc aaa hh b

③终止操作

每当终止语句执行后，这个流就会关闭

　　　　 /**
         * allMatch  检查是否所有元素都符合匹配条件
         * anyMatch  检查是否至少有一个元素符合匹配条件
         * noneMatch  检查是否没有元素匹配条件
         * findFirst  返回第一个元素
         * findAny  返回当前流中的任意元素
         * count  返回流中元素的个数
         * max  返回流中最大值
         * min  返回流中最小值
         * reduce(T identity,BinaryOperator) /reduce(BinaryOperator) 将流中元素反复结合起来,得到一个值
         * collect  收集，将流转换为其他形式，接收一个Conllector接口的实现，用于给stream中元素做汇总的方法
         */

        //allMatch,anyMatch,noneMatch
        List list = List.of("aa","bbb","c","dddd");
        Stream<String> stringStream = list.stream();
        //检查元素是否长度都大于5
        boolean b = stringStream.anyMatch((str) -> str.length() > 5);
        System.out.println(b);
        //结果为： false

        //count
        Stream<String> stringStream02 = list.stream();
        //取得元素长度
        long count = stringStream02.count();
        System.out.println(count);
        //结果为： 4

        //findFirst
        Stream<String> stringStream03 = list.stream();
        //取得第一个元素
        Optional<String> op = stringStream03.findFirst();
        //Optional 是一个java容器,具体不在此解释
        System.out.println(op.get());
        //结果为： aa

        //findAny
        Stream<String> stringStream04 = list.stream();
        Stream<String> stringStream05 = list.parallelStream();
        //取得任意元素
        //如果是parallelstream()并行流 就会多个线程去获取，结果会随机
        //但如果是stream()串行流 就只能获取第一个
        Optional<String> any = stringStream04.findAny();
        System.out.println(any.get());
        System.out.println(stringStream05.findAny().get());

        //max
        //取得流中长度最大值
        Stream<String> stringStream06 = list.stream();
        Optional<String> max = stringStream06.max(String::compareTo);
        System.out.println(max.get());

        //reduce
        //将流中所有字符串拼接
        Stream<String> stringStream07 = list.stream();
        Stream<String> stringStream08 = list.stream();
        //因为这个设置了起始值"" 避免了空指针, 所以结果为String类型
        String reduce = stringStream07.reduce("",String::concat);
        System.out.println(reduce);
        //这个没有起始值, 所以返回值类型为Optional
        Optional<String> reduce1 = stringStream08.reduce(String::concat);

        //collect
        //将流转换为容器list
        Stream<String> stringStream09 = list.stream();
        List<String> collect = stringStream09.collect(Collectors.toList());
        System.out.println(collect);
        //如果要转换成arraylist则需要Collectors.toCollection来转
        Stream<String> stringStream10 = list.stream();
        ArrayList<String> collect1 = stringStream10.collect(Collectors.toCollection(ArrayList::new));
        System.out.println(collect1);
        //Collectors里面有很多方法，比如求和,平均值,分组,多级分组,分区等很多灵活操作

原文地址：https://www.cnblogs.com/licha233/p/12693244.html