记录Stream流使用，集合、对象等

lizjf

已于 2024-10-11 13:57:30 修改

阅读量781

点赞数 10

文章标签： java spring boot

于 2024-02-06 05:30:00 首次发布

本文链接：https://blog.youkuaiyun.com/u013682979/article/details/136038705

版权

本文介绍了如何在Java开发中使用StreamAPI对List<Map>进行排序、去重、按字段汇总、分组、计算平均值等操作，包括自定义条件的过滤和属性映射实例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

记录开发中遇到关于stream流的使用，持续记录中...

1、List<Map> 按照某个字段排序

returnList.sort(Comparator.comparing(o -> new BigDecimal(o.getOrDefault("shipCount","0").toString()), Comparator.reverseOrder()));

2、List<Map> 按照某个字段distinct

List<Map<String, Object>> list = valueList.stream().filter(distinctByKey((p) -> (p.get("imo")))).collect(Collectors.toList());

public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {

    Map<Object, Boolean> seen = new ConcurrentHashMap<>();

    return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;

}

3、List<Map>按照某个字段汇总

totalDistanday = aList.stream()

        .mapToDouble(m -> Double.valueOf(m.getOrDefault("distanday", "0").toString()))

        .sum();

4、List<Map>按照某个字段分组

Map<String, List<Map<String, Object>>> companyList = listSocietyEmissions.stream()

        .collect(Collectors.groupingBy(

                m -> (String) m.getOrDefault("companyName","无")

        ));

5、List<Map>按照某个字段平均值

averageACo2Total = aList.stream()

        .mapToDouble(m -> Double.valueOf(m.getOrDefault("co2Total", "0").toString()))

        .average()

        .orElse(0);

6、数组求平均值

double average = Arrays.stream(data)

        .average()

        .orElse(0);

7、List<Map> 通过stream获取某个key的集合

List<String> imoList = list.stream()

        .map(m -> m.get("imo").toString)

        .collect(Collectors.toList());

8、List<Map>按照imo字段汇总计算属性

Map<String, Map<String, Double>> imoCo2DistandayMap = valueList.stream()

        .collect(Collectors.groupingBy(

                map -> String.valueOf(map.get("imo")),

                Collectors.mapping(

                        map -> {

                            Map<String, Double> co2DistandayMap = new HashMap<>();

                            if(map.get("co2Total") instanceof BigDecimal){

                                Optional.ofNullable(map.getOrDefault("co2Total",new BigDecimal(0)).toString()).ifPresent(s -> co2DistandayMap.put("co2Total", Double.parseDouble(s)));

                                Optional.ofNullable(map.getOrDefault("distanday",new BigDecimal(0)).toString()).ifPresent(s -> co2DistandayMap.put("distanday", Double.parseDouble(s)));

                            }else {

                                Optional.ofNullable(map.getOrDefault("co2Total", "0").toString()).ifPresent(s -> co2DistandayMap.put("co2Total", Double.parseDouble(s)));

                                Optional.ofNullable(map.getOrDefault("distanday", "0").toString()).ifPresent(s -> co2DistandayMap.put("distanday", Double.parseDouble(s)));

                            }

                            return co2DistandayMap;

                        },

                        Collectors.reducing(

                                new HashMap<>(),

                                (map1, map2) -> {

                                    map1.put("co2Total", map1.getOrDefault("co2Total", 0.0) + map2.get("co2Total"));

                                    map1.put("distanday", map1.getOrDefault("distanday", 0.0) + map2.get("distanday"));

                                    return map1;

                                }

                        )

                )

        ));

9、filter按照自定义条件过滤

List<T> resourceList = list.stream()

        .filter(t -> {

            try {

                Field shipownerIds = t.getClass().getDeclaredField("shipownerId");

                shipownerIds.setAccessible(true);

                String shipownerId = String.valueOf(shipownerIds.get(t));

                return ids.contains(shipownerId);

            } catch (NoSuchFieldException | IllegalAccessException e) {

                e.printStackTrace();

            }

            return false;

        })

        .collect(Collectors.toList());

10、查看集合中是否存在某个key值

boolean b = updateList.stream().anyMatch(m -> m.get("device_id").equals(device_id));

11、为集合中的某个属性循环赋值

sceneTestShips.forEach(p -> p.setId(IdUtils.snowFlake()));

12、返回集合中对象的某个属性值作为key，某个属性值作为value 的Map对象

Map<String, String> inputParams = shipModelObjectElements.stream()
                    .filter(s -> inputTableName.equals(s.getTableName()))
                    .collect(Collectors.toMap(ShipModelObjectElements::getFromCode, ShipModelObjectElements::getDefaultValue));

13、两个集合的交集、并集、差集

    List<AClass> aClassList1 = Lists.newArrayList();
    AClass aClass = new AClass(1, "zhuoli1", "haha1");
    aClassList1.add(aClass);
    aClassList1.add(new AClass(2, "zhuoli2", "haha2"));
    aClassList1.add(new AClass(3, "zhuoli3", "haha3"));
 
    List<AClass> aClassList2 = Lists.newArrayList();
    aClassList2.add(aClass);
    aClassList2.add(new AClass(5, "zhuoli5", "haha5"));
    aClassList2.add(new AClass(6, "zhuoli6", "haha6"));
 
    /*交集*/
    /*[AClass(id=1, name=zhuoli1, description=haha1)]*/
    List<AClass> intersectResult = aClassList1.stream().filter(aClassList2::contains).collect(Collectors.toList());
    System.out.println(intersectResult);
 
    /*并集*/
    List<AClass> unionResult = Stream.of(aClassList1, aClassList2).flatMap(Collection::stream).distinct().collect(Collectors.toList());
    assertEquals(unionResult.size(), 5);
    System.out.println(unionResult);
 
    /*差集*/
    /*[AClass(id=2, name=zhuoli2, description=haha2), AClass(id=3, name=zhuoli3, description=haha3)]*/
    List<AClass> differenceResult = aClassList1.stream().filter(x -> !aClassList2.contains(x)).collect(Collectors.toList());
    System.out.println(differenceResult);

14、合并map下多个集合

    map.put(1, new ListContainer(aClassList1));
    map.put(2, new ListContainer(aClassList2));
 
    /*合并多个list*/
    List<AClass> aClassListResult = map.values().stream().flatMap(listContainer -> listContainer.getLst().stream()).collect(Collectors.toList());
    /*注意跟并集的区别*/
    assertEquals(aClassListResult.size(), 6);