java8 stream案例分析

比眉伴天荒 2022-10-09 03:10 141阅读 0赞

#### java8 stream ####

*  Stream是java8 推出的一个处理集合类的一个全新的接口，在工作当中经常用到，并且他的预发规则与我们平台的有一点不一样，是流式的处理，非常类似RXJava的一个风格。
 *  java中对Stream的定义是：

A sequence of elements supporting sequential and parallel aggregate operations.

*  以上的的语义包含两部分：
    
     *  Stream是元素的集合，这点让Stream看起来有一些类似Iterator
     *  可以支持顺序和并行的对原Stream进行汇聚的操作
 *  刚学习Stream时候可以当一个高级的Iterator，原本的Iterator，用户只能逐个遍历每个元素，但是Stream用户只需要给出对其包含元素执行什么操作，也就是通过给Stream传递某一个的操作符或者方法，他会将集合中所有元素使用你给定的方法或者操作符进行修改。
 *  以下总结是我工作中用到的一些，会给出具体案例，初衷只是为了给自己一个参考，因为经常是在使用的时候，会忘记他的语法规则，或者忘记他的一些参数，以此作为一个记录。
 *  以下用到的基础对象：

/** * FM表Result */
    public class FmResult implements Serializable { 
        public FmResult() { 
        }
    
        public FmResult(Integer sortNo, String platform) { 
            this.sortNo = sortNo;
            this.platform = platform;
        }
    
        /** * 序列化ID */
        private static final long serialVersionUID = 7327233719573948963L;
    
    
        /** * 主键ID */
        private Long id;
    
        /** * 排序值 */
        private Integer sortNo;
    
        /** * FM名称 */
        private String fmName;
    
    
        /** * 开放平台号，多个半角逗号隔开 */
        private String platform;
    
        public Long getId() { 
            return id;
        }
    
        public void setId(Long id) { 
            this.id = id;
        }
    
        public Integer getSortNo() { 
            return sortNo;
        }
    
        public void setSortNo(Integer sortNo) { 
            this.sortNo = sortNo;
        }
    
        public String getFmName() { 
            return fmName;
        }
    
        public void setFmName(String fmName) { 
            this.fmName = fmName;
        }
    
        public String getPlatform() { 
            return platform;
        }
    
        public void setPlatform(String platform) { 
            this.platform = platform;
        }
    }

#### Stream 流操作 ####

/** * Stream 流操作 * * 类似Rxjava中的流操作 * */
        public static void streamBuildList(){ 
            //stream 快速成成list
            List<Integer> ofList = Stream.of(1,2,3,4,5).collect(Collectors.toList());
            //安指定规律生成流
            List<Integer> iteraterList = Stream.iterate(1, (x) -> x+2).limit(100).collect(Collectors.toList());
            //生成随机数流
            List<Double> generateList = Stream.generate(Math::random).limit(199).collect(Collectors.toList());
        }

#### Stream 流元素操作 ####

/** * Stream 流中间操作 * distinct 更具hashCode，equals 反复去重 * filter过滤 * skip 跳过n个元素 * limit获取n个元素 * */
        public static void streamTest(){ 
            //生成随机数流
            List<Double> generateList = Stream.generate(Math::random).limit(199).collect(Collectors.toList());
            List<Double> myDubleLIst = generateList.stream().filter(d -> d > 0.5)
                    .distinct()
                    .skip(4)
                    .limit(20).collect(Collectors.toList());
            myDubleLIst.forEach(System.out::println);
        }

#### Stream map表达式映射 ####

/** * Stream map表达式映射 * */
        public static void testStreamMap(List<FmResult> list){ 
            //传递一个函数给map，他会映射到每一个元素上
            Set<String> resultlist = list.stream().map(result -> result.getPlatform().replace(",", "")).collect(Collectors.toSet());
            //复杂表达式处理
            List<FmResult> fmResults = list.stream().map( result -> { 
                result.setPlatform(result.getPlatform().substring(0,1));
                return result;
            }).collect(Collectors.toList());
        }

#### Stream peek消费元素 ####

/** * Stream peek消费元素 * peek 和map操作一样，当peek接受的是一个Consumer 表达式没有返回值，map接受的是Function表达式有返回值 * */
        public static void testStreamPeek(){ 
            FmResult result1 = new FmResult(1,"aa");
            FmResult result2 = new FmResult(2,"bb");
            FmResult result3 = new FmResult(3,"aa");
            FmResult result4 = new FmResult(4,"dd");
            List<FmResult> fmResults = Arrays.asList(result1,result2, result3, result4);
            List<FmResult> newResults = fmResults.stream().peek(result -> result.setFmName("123123")).collect(Collectors.toList());
            for (FmResult newResult: newResults) { 
                System.out.println(newResult.getSortNo() + ": "+ newResult.getPlatform() + ": "+ newResult.getFmName());
            }
        }

#### Stream flatMapToInt,flatMapToDouble,flatMapToLong ####

/** * Stream flatMapToInt,flatMapToDouble,flatMapToLong * 一对多，将一个元素拆分成多个元素，流元素变多，map是一对一 * */
        public static void testStreamFlagMap(){ 
            FmResult result1 = new FmResult(1,"aa");
            FmResult result2 = new FmResult(2,"bb");
            FmResult result3 = new FmResult(3,"aa");
            FmResult result4 = new FmResult(4,"dd");
            List<FmResult> fmResults = Arrays.asList(result1,result2, result3, result4);
            IntStream platformStream = fmResults.stream().map(FmResult::getPlatform).flatMapToInt(String::chars);
            int[] ints = platformStream.toArray();
            System.out.println(ints.length +" :"+ ints[0]);
    
        }

#### Stream 流的终止操作 ####

/** * Stream 流的终止 * allMatch：接收一个 Predicate 函数，当流中每个元素都符合该断言时才返回true，否则返回false * noneMatch：接收一个 Predicate 函数，当流中每个元素都不符合该断言时才返回true，否则返回false * anyMatch：接收一个 Predicate 函数，只要流中有一个元素满足该断言则返回true，否则返回false * findFirst：返回流中第一个元素 * findAny：返回流中的任意元素 * count：返回流中元素的总个数 * max：返回流中元素最大值 * min：返回流中元素最小值 * */
        public static void testStreamTermal(){ 
            List<String>  strList = Arrays.asList("a2","a1","b4","c1","d5","a6");
            boolean allMatch = strList.stream().allMatch(str -> str.equals("a1"));
            boolean noneMatch = strList.stream().noneMatch(str -> str.equals("x"));
            boolean anyMatch = strList.stream().anyMatch(str -> str.equals("a1"));
    
            String findFirst = strList.stream().findFirst().get();
            String findAny = strList.stream().findAny().get();
    
            Long count = strList.stream().count();
            String max = strList.stream().max(String::compareTo).get();
            String min = strList.stream().min(String::compareTo).get();
    
        }

#### Stream 排序处理 ####

/** * Stream 排序处理 * */
        public static void testStreamSort(){ 
            //String 自己已经实现了Compareable接口
            List<String>  strList = Arrays.asList("a2","a1","b4","c1","d5","a6");
            strList.stream().sorted().forEach(System.out::print);
            System.out.println();
            //自实现Compareable接口
            FmResult result1 = new FmResult(1,"aa");
            FmResult result2 = new FmResult(2,"bb");
            FmResult result3 = new FmResult(3,"aa");
            FmResult result4 = new FmResult(4,"dd");
            List<FmResult> fmResults = Arrays.asList(result1,result2, result3, result4);
            List<FmResult> sortResults = fmResults.stream().sorted(
                    (k1,k2)->{ 
                        if(k1.getPlatform().equals(k2.getPlatform())){ 
                            return k1.getSortNo()-k2.getSortNo();
                        }else { 
                            return k1.getPlatform().compareTo(k2.getPlatform());
                        }
                    }
            ).collect(Collectors.toList());
            for (FmResult sortResult : sortResults) { 
                System.out.println(sortResult.getSortNo() + ": "+ sortResult.getPlatform());
            }
        }

#### Stream 表达式list 转 map ####

/** * Stream 表达式list -->map * (key1, key2) -> key1 作用在于如果存在相同id的数据，取第一个 * */
        public static Map<Long, FmResult> streamListTOMap(List<FmResult> list){ 
            return list.stream().collect(Collectors.toMap(FmResult::getId, Function.identity(), (key1, key2) -> key1));
        }

#### Stream groupingBy分组 ####

/** * Stream 表达式 list --> map groupingBy分组 * */
        public static void streamGroupingBy(List<FmResult> list){ 
            Map<String, List<FmResult>> fmMap = list.stream().collect(Collectors.groupingBy(FmResult::getPlatform));
            //按排平台分组，并返回数量
            Map<String, Long> fmCountMap = list.stream().collect(Collectors.groupingBy(FmResult::getPlatform, Collectors.counting()));
        }

#### Stream partitioningBy分区 ####

/** * Stream partitioningBy分区 * 按排序值 > 2 分组 * */
        public static Map<Boolean, List<FmResult>> streamPartitioningBy(List<FmResult> list){ 
            return list.stream().collect(Collectors.partitioningBy(x -> x.getSortNo() > 2));
        }

#### Stream 连接 joining ####

/** * Stream 连接 joining * */
        public  static void streamJoining(){ 
            FmResult result1 = new FmResult(1,"aa");
            FmResult result2 = new FmResult(2,"bb");
            FmResult result3 = new FmResult(3,"aa");
            FmResult result4 = new FmResult(4,"dd");
            List<FmResult> fmResults = Arrays.asList(result1,result2, result3, result4);
            String platform = fmResults.stream().map(result -> result.getPlatform()).collect(Collectors.joining(","));
            System.out.println(platform);
        }

#### Stream 规约 reducing ####

/** * Stream 规约 reducing * */
        public static void streamReducing(){ 
            FmResult result1 = new FmResult(1,"aa");
            FmResult result2 = new FmResult(2,"bb");
            FmResult result3 = new FmResult(3,"aa");
            FmResult result4 = new FmResult(4,"dd");
            List<FmResult> fmResults = Arrays.asList(result1,result2, result3, result4);
            Optional<Integer> sumSortNo = fmResults.stream().map(result ->result.getSortNo()).collect(Collectors.reducing(Integer::sum));
            System.out.println(sumSortNo.get());
        }

#### stream Collectors.averagingDouble()、Collectors.averagingInt()、Collectors.averagingLong() ： 计算平均数 ####

/** * stream Collectors.averagingDouble()、Collectors.averagingInt()、Collectors.averagingLong() ： 计算平均数 * */
        public static void streamAveraging(){ 
            FmResult result1 = new FmResult(1,"aa");
            FmResult result2 = new FmResult(2,"bb");
            FmResult result3 = new FmResult(3,"aa");
            FmResult result4 = new FmResult(4,"dd");
            List<FmResult> fmResults = Arrays.asList(result1,result2, result3, result4);
            Double avgSortNo = fmResults.stream().collect(Collectors.averagingInt(FmResult::getSortNo));
        }

#### 其他api遇到了在补充 ####