Stream实践总结

怼烎@ 2022-09-12 02:57 258阅读 0赞

### 文章目录 ###

*   *  foreach
     *   *  使用 forEach操作集合每个元素对象
         *   *  操作集合元素，方法体只有一行代码
             *  操作集合元素，有方法体
     *  filter
     *   *   *  统计集合中符合特定条件的数量
     *  max和min
     *   *   *  获取 String 集合中最长的元素
             *  获取 Integer 集合中的最大值
             *  对象类型的比较
     *  map/flatMap
     *   *   *  英文字符串数组的元素全部改为大写
             *  flatMap将两个字符数组合并成一个新的字符数组
     *  reduce
     *   *   *  reduce进行求和、求乘积的方式
     *  统计(count/averaging)
     *  分组(partitioningBy/groupingBy)
     *   *   *  根据员工的level进行分组
     *  接合(joining)
     *   *   *  将员工列表的姓名使用特定符号拼接成字符串
     *  排序(sorted)
     *   *   *  根据工资倒序排列

## foreach ##

### 使用 forEach操作集合每个元素对象 ###

dataVoList.stream().forEach();可以简化为dataVoList.forEach

#### 操作集合元素，方法体只有一行代码 ####

List<DataVo> dataVoList = DataVo.dataVoList;
            //forEach操作
            dataVoList.forEach(p-> p.setDesc("描述信息"));
            //打印输出
            dataVoList.forEach(System.out::println);

#### 操作集合元素，有方法体 ####

List<DataVo> dataVoList = DataVo.dataVoList;
            //forEach操作
            dataVoList.forEach(
                    p->{ 
                        p.setDesc("描述信息");
                        p.setCreateTime(new Date());
                    }
            );
            //打印输出
            dataVoList.forEach(System.out::println);

## filter ##

#### 统计集合中符合特定条件的数量 ####

计算 Integer 集合中大于 6 的元素的个数

/** * * 统计集合中符合特定条件的数量 * 1：过滤条件 * 2：完成统计计数 * */
        @Test
        public  void test6(){ 
           //计算 Integer 集合中大于 6 的元素的个数。
            List<Integer> list = Arrays.asList(7, 6, 4, 8, 2, 11, 9);
            long count = list.stream().filter(p -> p > 6).count();
            System.out.println(count);
        }

## max和min ##

#### 获取 String 集合中最长的元素 ####

/** * 获取 String 集合中最长的元素 */
        @Test
        public void test3() { 
            List<String> list = Arrays.asList("111", "222", "333", "4234224324", "5435435");
            Optional<String> max = list.stream().max(Comparator.comparing(String::length));
            System.out.println(max);
        }

#### 获取 Integer 集合中的最大值 ####

/** * 获取 Integer 集合中的最大值 **/
        @Test
        public  void test4(){ 
            List<Integer> list = Arrays.asList(2, 22,3443,666,111,-2);
            Optional<Integer> max = list.stream().max(Comparator.comparingInt(Integer::intValue));
            System.out.println(max);
        }

#### 对象类型的比较 ####

/** * 对象类型的比较 * 【示例】 * 1：首先根据工资进行比较，返回最高的那个 * 2：如果工资相同，在根据职级比较，俩个条件都是返回最高那个 * */
        @Test
        public  void test5(){ 
            List<Emp> empList=new ArrayList<>(3);
            empList.add(new Emp("张三",6500d,3));
            empList.add(new Emp("李斯特",7200d,1));
            empList.add(new Emp("李四",6000d,3));
            empList.add(new Emp("王五",7200d,3));
            //多个条件可以使用thenComparingXXX并列使用
            Optional<Emp> max = empList.stream().max(Comparator.comparingDouble(Emp::getSalary).thenComparingDouble(Emp::getLevel));
            System.out.println(max);
        }
        @Data
        @AllArgsConstructor
        class  Emp{ 
            String name;
            Double salary;
            int level;
        }

## map/flatMap ##

映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为 map 和 flatMap：  
map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。  
![在这里插入图片描述][4a1aa8e860014de6ab6f177cac879114.png]

#### 英文字符串数组的元素全部改为大写 ####

/** * 将字符串集合中的字符转换为大写字符 */
        @Test
        public  void test7(){ 
            List<String> list = Arrays.asList("aaa", "bbb", "rrer", "ewew", "sdsds");
            List<String> collect = list.stream().map(String::toUpperCase).collect(Collectors.toList());
            System.out.println(collect);
        }

#### flatMap将两个字符数组合并成一个新的字符数组 ####

flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。  
![在这里插入图片描述][49bbebcd8bb4425e9e5950078a1b93dc.png]

@Test
        public  void test8(){ 
            List<String> list = Arrays.asList("a,b,c,d", "1,2,3,4");
            List<String> listNew = list.stream().flatMap(s -> { 
                // 将每个元素转换成一个stream
                 String[] split = s.split(",");
                return Arrays.stream(split);
            }).collect(Collectors.toList());
            System.out.println(listNew);
        }

## reduce ##

归约(reduce)  
归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。

#### reduce进行求和、求乘积的方式 ####

/** * reduce进行求和、求乘积的方式 */
        @Test
        public  void test9(){ 
            List<Integer> list = Arrays.asList(1, 3, 5, 7, 9, 15);
            // 求和方式1
            Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
            // 求和方式2
            Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
            // 求和方式
            Integer sum3 = list.stream().reduce(0, Integer::sum);
            // 求乘积
            Optional<Integer> product = list.stream().reduce((x, y) -> x * y);
            // 求最大值方式1
            Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
            // 求最大值写法2
            Integer max2 = list.stream().reduce(1, Integer::max);
        }

## 统计(count/averaging) ##

Collectors 提供了一系列用于数据统计的静态方法：

计数：count  
平均值：averagingInt、averagingLong、averagingDouble  
最值：maxBy、minBy  
求和：summingInt、summingLong、summingDouble  
统计以上所有：summarizingInt、summarizingLong、summarizingDouble

@Test
        public  void test10(){ 
            List<Emp> empList=new ArrayList<>(3);
            empList.add(new Emp("张三",6500d,3));
            empList.add(new Emp("李斯特",7200d,1));
            empList.add(new Emp("李四",6000d,3));
            empList.add(new Emp("王五",7200d,3));
            // 求总数
            long count1 = empList.stream().collect(Collectors.counting());
            //简写
            long count2 = empList.stream().count();
            
            
            // 求平均工资 
            Double average = empList.stream().collect(Collectors.averagingDouble(Emp::getSalary)); 
            
            
            // 求最高工资 
            Optional<Double> max = empList.stream().map(Emp::getSalary).collect(Collectors.maxBy(Double::compare));
            
            // 求工资之和 
            Double sum1 = empList.stream().collect(Collectors.summingDouble(Emp::getSalary)); 
            //简写
            Double sum2 = empList.stream().mapToDouble(Emp::getSalary).sum(); 
            
            // 一次性统计所有信息
            DoubleSummaryStatistics collect = empList.stream().collect(Collectors.summarizingDouble(Emp::getSalary));
            
        }

## 分组(partitioningBy/groupingBy) ##

分区：将 stream 按条件分为两个 Map，比如员工按薪资是否高于 8000 分为两部分。

分组：将集合分为多个 Map，比如员工按性别分组。有单级分组和多级分组。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWldaaGFuZ1l1_size_20_color_FFFFFF_t_70_g_se_x_16]

#### 根据员工的level进行分组 ####

/** * 分组(partitioningBy/groupingBy) * 根据员工的level进行分组 */
        @Test
        public  void test11(){ 
            List<Emp> empList=new ArrayList<>(3);
            empList.add(new Emp("张三",6500d,3));
            empList.add(new Emp("李斯特",7200d,1));
            empList.add(new Emp("李四",6000d,1));
            empList.add(new Emp("王五",7200d,3));
            Map<Integer, List<Emp>> collect = empList.stream().collect(Collectors.groupingBy(Emp::getLevel));
            for (Map.Entry<Integer, List<Emp>> integerListEntry : collect.entrySet()) { 
                System.out.println(integerListEntry);
            }
            
        }

## 接合(joining) ##

joining 可以将 stream 中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。

#### 将员工列表的姓名使用特定符号拼接成字符串 ####

/** * 接合(joining) * 将员工列表的姓名使用特定符号拼接成字符串 */
        @Test
        public  void test12(){ 
            List<Emp> empList=new ArrayList<>(3);
            empList.add(new Emp("张三",6500d,3));
            empList.add(new Emp("李斯特",7200d,1));
            empList.add(new Emp("李四",6000d,1));
            empList.add(new Emp("王五",7200d,3));
            String collect = empList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
            System.out.println(collect);
        }

## 排序(sorted) ##

sorted，中间操作。有两种排序：

sorted()：自然排序，流中元素需实现 Comparable 接口  
sorted(Comparator com)：Comparator 排序器自定义排序

#### 根据工资倒序排列 ####

@Test
        public  void test12(){ 
            List<Emp> empList=new ArrayList<>(3);
            empList.add(new Emp("张三",6500d,3));
            empList.add(new Emp("李斯特",7300d,1));
            empList.add(new Emp("李四",6000d,1));
            empList.add(new Emp("王五",7200d,3));
            //根据工资倒序排列
            List<Emp> collect = empList.stream().sorted((o1, o2) -> { 
                //逆序只需要Double.compare翻转顺序即可
                return Double.compare(o2.getSalary(), o1.getSalary());
            }).collect(Collectors.toList());
            System.out.println(collect);
        }

[4a1aa8e860014de6ab6f177cac879114.png]: /images/20220828/7d03a77e9f874636839a4413bc68138e.png
[49bbebcd8bb4425e9e5950078a1b93dc.png]: /images/20220828/e5c44e4568f749608b4650567bdaaa53.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWldaaGFuZ1l1_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/3d491bb8201c42b2b2ee345506e51ed9.png