0
0

Java List Stream流操作实战教学，轻松分组、合并、筛选、拼接、拆分、替换，复制可用！

1、前言

今日无事，记录下常用的一些Stream流操作。

很多案例只是提供思路，活学活用！

废话不多说直接上干货！

2、实体类

设置几个常见属性；

  1. @Data
  2. @AllArgsConstructor
  3. @NoArgsConstructor
  4. public class User implements Serializable {
  6.     private String userId;
  8.     private String userName;
  10.     private String areaCode;
  12.     private String areaName;
  14.     private Integer workDay;
  16. }

3、具体操作

1、提取某一属性作为List 常用于数据处理时抽取特定字段

  1.   /*
  2.          *1、Stream 只取某一字段作为List sorted排序 distinct 去重
  3.          */
  4.         List<String> areaCodes = userList.stream().map(User::getAreaCode).sorted().distinct().collect(Collectors.toList());
  5.         System.out.println(areaCodes);
  6.         List<String> names = userList.stream().map(User::getUserName).distinct().collect(Collectors.toList());
  7.         System.out.println(names);

效果：

2、stream 替换某一字段属性 常用于更改特定值

  1.  /*
  2.         2、stream 替换某一字段属性  替换workDay
  3.          */
  5.         List<User> newUserList = userList.stream().map(a -> {
  6.             String xzqhdm = a.getAreaCode();
  7.             switch (xzqhdm) {
  8.                 //雄安新区规划
  9.                 case "130100":
  10.                     a.setWorkDay(20);
  11.                     break;
  12.                 case "130200":
  13.                     a.setWorkDay(22);
  14.                     break;
  16.             }
  17.             return a;
  18.         }).collect(Collectors.toList());
  19.         newUserList.stream().forEach(a->{
  20.             System.out.println(a);
  21.         });

效果：

3、根据某字段排序

  1.    /*
  2.              3、根据某字段排序逆序
  3.         */
  5.         List<User> reverseOrderCollect = userList.stream()
  6.                 .sorted(Comparator.comparing(User::getUserId, Comparator.reverseOrder()))
  7.                 .collect(Collectors.toList());
  8.         System.out.println("--排序逆序--");
  9.         reverseOrderCollect.stream().forEach(a->{
  10.             System.out.println(a);
  11.         });
  13.         List<User> sortCollect = userList.stream()
  14.                 .sorted(Comparator.comparing(User::getUserId))
  15.                 .collect(Collectors.toList());
  16.         System.out.println("--排序--");
  17.         sortCollect.stream().forEach(a->{
  18.             System.out.println(a);
  19.         });

效果：

4、筛选出符合条件数据 并取单一属性 常用与数据集筛选

  1.   /*
  2.         4、筛选出符合条件数据 并取单一属性 （筛选areacode为130100 的数据湖）
  3.          */
  4.         List<User> user130100List = userList.stream().filter(a -> "130100".equals(a.getAreaCode())).collect(Collectors.toList());
  5.         System.out.println("--筛选出符合条件数据 并取单一属性--");
  6.         user130100List.stream().forEach(a->{
  7.             System.out.println(a);
  8.         });

效果：

5、根据某一字段是否包含字符分组 true、false 也可按照属性分组 常和6一起用处理数据

  1.  /*
  2.         5、根据某一字段是否包含字符分组 true、false
  3.          */
  5.         Map<Boolean, List<User>> groupByMap = userList.stream().collect(Collectors.groupingBy(
  6.                 a -> a.getUserName().contains("赵")
  7.         ));
  8.         System.out.println("--根据某一字段是否包含字符分组-");
  9.         System.out.println(groupByMap.get(true));
  10.         System.out.println(groupByMap.get(false));

效果：

6、分组后遍历map执行方法

  1.    System.out.println("--根据某一字段是否包含字符分组-");
  2.         groupByMap.forEach((isZhao, list) ->
  3.                 testZhao(isZhao, list)
  4.         );
  6.   private static void testZhao(Boolean isZhao, List<User> list){
  7.         if (isZhao){
  8.             list.stream().forEach(a->{
  9.                 System.out.println("赵氏精英");
  10.             });
  11.         }else{
  12.             list.stream().forEach(a->{
  13.                 System.out.println("非赵氏精英");
  14.             });
  16.         }
  17.     }

效果：

7、根据某一属性拼接逗号 常用于共有属性字段拼接

  1.   /*
  2.         7、 根据某一字段拼接","
  3.          */
  4.         String allUserName = userList.stream()
  5.                 .map(User::getUserName)
  6.                 .collect(Collectors.joining(","));
  7.         System.out.println("--根据某一字段拼接\",\"--");
  8.         System.out.println(allUserName);

效果

8、根据某一字段分组

  1.     /*
  2.         8、根据某一字段分组
  3.          */
  4.         Map<String, List<User>> groupingByMap = userList.stream()
  5.                 .collect(Collectors.groupingBy(User::getAreaCode));
  6.         System.out.println("--根据某一字段分组--");
  7.         System.out.println(groupingByMap.get("130100"));
  8.         System.out.println(groupingByMap.get("130200"));

效果：

9、根据两个list集合某相同属性合并（赋值）

  1.    /*
  2.         9\根据某属性合并或替换两个list集合 (根据username 合并workday)
  3.          */
  4.         userList = userList.stream().map(m -> {
  5.             newUserList.stream().filter(m2 -> Objects.equals(m.getUserName(), m2.getUserName())).forEach(
  6.                     m2 -> {
  7.                         m.setWorkDay(m2.getWorkDay()+m.getWorkDay());
  8.                         m.setAreaCode(String.valueOf(m.getWorkDay()));
  9.                     });
  10.             return m;
  11.         }).collect(Collectors.toList());
  12.         System.out.println("--根据某属性合并两个list集合--");
  13.         userList.stream().forEach(a->{
  14.             System.out.println(a);
  15.         });

效果：

10、根据某属性去重

  1.   System.out.println("--去重--");
  2.         userList.stream()
  3.                 .filter(distinctByKey1(a->a.getWorkDay()))
  4.                .forEach(System.out::println);
  6.  static <T> Predicate<T> distinctByKey1(Function<? super T, ?> keyExtractor) {
  7.         Map<Object, Boolean> seen = new ConcurrentHashMap<>();
  8.         return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
  9.     }

效果：

11、根据某字段拆分为有序List

  2.         /*
  3.         11、根据某字段拆分为有序List
  4.          */     
  5.  System.out.println("--拆分有序list--");
  6.          userList.stream()
  7.                 //默认hashmap 无序，需要设置有序map
  8.                 .collect(Collectors.groupingBy(User::getAreaCode, LinkedHashMap::new, Collectors.toList()))
  9.                 .values().stream().collect(Collectors.toList()).forEach(System.out::println);

效果：

4、完整代码

  1.  private static String[] NAME = new String[]{
  2.             "赵牛马", "钱牛马", "孙牛马", "李牛马", "周牛马"
  4.     };
  6.     public static void main(String[] args) {
  7.         List<String> nameList = Arrays.asList(NAME);
  8.         List<User> userList = new ArrayList<>();
  9.         User user;
  10.         for (int i = 0; i < 5; i++) {
  11.             user = new User();
  12.             user.setUserId(String.valueOf(i));
  13.             user.setUserName(nameList.get(i) + (i + 1) * 2);
  14.             if ((i & 1) == 0) {
  15.                 user.setAreaCode("130200");
  16.                 user.setAreaName("唐山");
  17.             } else {
  18.                 user.setAreaCode("130100");
  19.                 user.setAreaName("石家庄");
  20.             }
  21.             user.setWorkDay((i + 7) * (i + 1));
  22.             System.out.println(user);
  23.             userList.add(user);
  24.         }
  25.         /*
  26.          *1、Stream 只取某一字段作为List sorted排序
  27.          */
  28.         List<String> years = userList.stream().map(User::getAreaCode).sorted().distinct().collect(Collectors.toList());
  29.         System.out.println(years);
  30.         List<String> names = userList.stream().map(User::getUserName).distinct().collect(Collectors.toList());
  31.         System.out.println(names);
  32.         /*
  33.         2、stream 替换某一字段属性  替换workDay
  34.          */
  36.         List<User> newUserList = userList.stream().map(a -> {
  37.             String xzqhdm = a.getAreaCode();
  38.             switch (xzqhdm) {
  39.                 //雄安新区规划
  40.                 case "130100":
  41.                     a.setWorkDay(33);
  42.                     break;
  43.                 case "130200":
  44.                     a.setWorkDay(12);
  45.                     break;
  47.             }
  48.             return a;
  49.         }).collect(Collectors.toList());
  50.         System.out.println("--替换某一字段属性 --");
  51.         newUserList.stream().forEach(a -> {
  52.             System.out.println(a);
  53.         });
  54.         /*
  55.              3、根据某字段排序逆序
  56.         */
  58.         List<User> reverseOrderCollect = userList.stream()
  59.                 .sorted(Comparator.comparing(User::getUserId, Comparator.reverseOrder()))
  60.                 .collect(Collectors.toList());
  61.         System.out.println("--排序逆序--");
  62.         reverseOrderCollect.stream().forEach(a -> {
  63.             System.out.println(a);
  64.         });
  66.         List<User> sortCollect = userList.stream()
  67.                 .sorted(Comparator.comparing(User::getUserId))
  68.                 .collect(Collectors.toList());
  69.         System.out.println("--排序--");
  70.         sortCollect.stream().forEach(a -> {
  71.             System.out.println(a);
  72.         });
  73.         /*
  74.         4、筛选出符合条件数据 并取单一属性 （筛选areacode为130100 的数据湖）
  75.          */
  76.         List<User> user130100List = userList.stream().filter(a -> "130100".equals(a.getAreaCode())).collect(Collectors.toList());
  77.         System.out.println("--筛选出符合条件数据 并取单一属性--");
  78.         user130100List.stream().forEach(a -> {
  79.             System.out.println(a);
  80.         });
  82.         /*
  83.         5、根据某一字段是否包含字符分组 true、false
  84.          */
  86.         Map<Boolean, List<User>> groupByMap = userList.stream().collect(Collectors.groupingBy(
  87.                 a -> a.getUserName().contains("赵")
  88.         ));
  89.         System.out.println("--根据某一字段是否包含字符分组-");
  90.         System.out.println(groupByMap.get(true));
  91.         System.out.println(groupByMap.get(false));
  93.         /*
  94.          * 6、根据某一字段是否包含某字符串拆分并遍历
  95.          */
  96.         System.out.println("--根据某一字段是否包含字符分组-");
  97.         groupByMap.forEach((isZhao, list) ->
  98.                 testZhao(isZhao, list)
  99.         );
  101.         /*
  102.         7、 根据某一字段拼接","
  103.          */
  104.         String allUserName = userList.stream()
  105.                 .map(User::getUserName)
  106.                 .collect(Collectors.joining(","));
  107.         System.out.println("--根据某一字段拼接\",\"--");
  108.         System.out.println(allUserName);
  110.         /*
  111.         8、根据某一字段分组
  112.          */
  113.         Map<String, List<User>> groupingByMap = userList.stream()
  114.                 .collect(Collectors.groupingBy(User::getAreaCode));
  115.         System.out.println("--根据某一字段分组--");
  116.         System.out.println(groupingByMap.get("130100"));
  117.         System.out.println(groupingByMap.get("130200"));
  118.         /*
  119.         9\根据某属性合并或替换两个list集合 (根据username 合并workday)
  120.          */
  121.         userList = userList.stream().map(m -> {
  122.             newUserList.stream().filter(m2 -> Objects.equals(m.getUserName(), m2.getUserName())).forEach(
  123.                     m2 -> {
  124.                         m.setWorkDay(m2.getWorkDay() + m.getWorkDay());
  125.                         m.setAreaCode(String.valueOf(m.getWorkDay()));
  126.                     });
  127.             return m;
  128.         }).collect(Collectors.toList());
  129.         System.out.println("--根据某属性合并两个list集合--");
  130.         userList.stream().forEach(a -> {
  131.             System.out.println(a);
  132.         });
  134.         /*
  135.         10、去重
  136.          */
  137.         System.out.println("--去重--");
  138.         userList.stream()
  139.                 .filter(distinctByKey1(a -> a.getWorkDay()))
  140.                 .forEach(System.out::println);
  142.         /*
  143.         11、根据某字段拆分为有序List
  144.          */
  145.         System.out.println("--拆分有序list--");
  146.          userList.stream()
  147.                 //默认hashmap 无序，需要设置有序map
  148.                 .collect(Collectors.groupingBy(User::getAreaCode, LinkedHashMap::new, Collectors.toList()))
  149.                 .values().stream().collect(Collectors.toList()).forEach(System.out::println);
  150.     }
  152.     private static void testZhao(Boolean isZhao, List<User> list) {
  153.         if (isZhao) {
  154.             list.stream().forEach(a -> {
  155.                 System.out.println("赵氏精英");
  156.             });
  157.         } else {
  158.             list.stream().forEach(a -> {
  159.                 System.out.println("非赵氏精英");
  160.             });
  162.         }
  163.     }
  165.     static <T> Predicate<T> distinctByKey1(Function<? super T, ?> keyExtractor) {
  166.         Map<Object, Boolean> seen = new ConcurrentHashMap<>();
  167.         return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
  168.     }
标签： java 开发语言
本文转载自: https://blog.csdn.net/Su7148/article/details/141681913
版权归原作者 云梦轻掩楼 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Java List Stream流操作实战教学，轻松分组、合并、筛选、拼接、拆分、替换，复制可用！”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？