【Stream数据操作】

Stream数据操作：

1.数据去重 跟进集合中单个和多个元素去重

	//toMap
   List<Test> distinctList = new ArrayList<Test>(list.stream()
                    .collect(Collectors.toMap(Test::getId,
                            Function.identity(),
                            (existing, replacement) -> existing))
                    .values());

List<Test> distinctList = new ArrayList<>(list.stream()
                                    .collect(Collectors.toMap(
                                        test -> Arrays.asList(test.getId1(), test.getId2(), test.getId3()), // 复合键
                                        Function.identity(),
                                        (existing, replacement) -> existing))
                                    .values());



	//TreeSet
	List<Test> distinctList = list.stream()
                             .collect(Collectors.collectingAndThen(
                                 Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Test::getId))),
                                 ArrayList::new));


List<Test> distinctList = list.stream()
                              .collect(Collectors.collectingAndThen(
                                  Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(test ->
                                      Arrays.asList(test.getId1(), test.getId2(), test.getId3())))),
                                  ArrayList::new));

2. 获取集合元素String：“1,2,3”;转为List；字符串处理

  List<Integer> roleIdList = list.stream()
                .map(UserRoleVo::getRoleId)
                .flatMap(roleIds -> Arrays.stream(roleIds.split(",")))
                .map(Integer::parseInt)
                .distinct()
                .collect(Collectors.toList());

	//字符串转集合
  List<Integer> userIdList = Arrays.stream(haveImageUserIds1.split(","))
                .map(Integer::parseInt)
                .collect(Collectors.toList());
   //获取集合中元素String："1,2,3";转为List<Integer> 并按源集合id分组（Java9以上）
 Map<Integer, List<Integer>> collect = permissionIds.stream()
                .collect(Collectors.groupingBy(
                        TUserRoles::getId,
                        Collectors.flatMapping(
                                item -> Arrays.stream(item.getPermissionId().split(","))
                                        .map(Integer::parseInt),
                                Collectors.toList()
                        )
                ));
``

3.Java 8的流操作来实现将包含逗号分隔整数字符串的List转换为List。

        List<String> stringList = new ArrayList<>();
        stringList.add("1,2,3");
        stringList.add("5,6");
        stringList.add("88");
        
        List<Integer> integerList = stringList.stream()
                .flatMap(str -> Arrays.stream(str.split(",")) // 将逗号分隔的字符串拆分为流
                        .map(Integer::parseInt) // 将字符串转换为整数
                )
                .collect(Collectors.toList());

4.List list 集合中有batchNumber和breedId还有price字段，我需要把batchNumber和breedId相同的数据合成一条数据，合成的这一条数据所有的price相加set这条数据的price上

```Map<String, Double> mergedData = list.stream()
    .collect(Collectors.toMap(
        catVo -> catVo.getBatchNumber() + catVo.getBreedId(),
        PurchaseCalendarCatVo::getPrice,
        Double::sum
    ));

List<PurchaseCalendarCatVo> mergedList = mergedData.entrySet().stream()
    .map(entry -> {
        String[] keys = entry.getKey().split(" ");
        PurchaseCalendarCatVo mergedCatVo = new PurchaseCalendarCatVo();
        mergedCatVo.setBatchNumber(keys[0]);
        mergedCatVo.setBreedId(keys[1]);
        mergedCatVo.setPrice(entry.getValue());
        return mergedCatVo;
    })
    .collect(Collectors.toList());

5.集合根据对应属性排序

    /**
     * 集合根据对应属性排序
     * @param list list
     * @param propertyExtractor 属性
     * @param reverse 是否倒序
     * @return 排序后的集合
     * @param <T> 接受类型为 T 的对象
     * @param <U> 返回一个 U 类型的可比较属性
     */
    public static <T, U extends Comparable<? super U>> List<T> sortByProperty(List<T> list, Function<? super T, ? extends U> propertyExtractor, boolean reverse) {
        return list.parallelStream()
                .sorted(reverse ? Comparator.comparing(propertyExtractor, Comparator.reverseOrder()) : Comparator.comparing(propertyExtractor))
                .collect(Collectors.toList());
    }

6.根据日期范围过滤集合

 /**
     * 根据日期范围过滤集合1
     * @param <T> 集合元素的类型
     * @param list 要过滤的集合
     * @param startDate 范围开始日期
     * @param endDate 范围结束日期
     * @param dateExtractor 提取日期的函数
     * @return 过滤后的集合
     */
    public static <T> List<T> filterByDateRange(List<T> list, LocalDate startDate, LocalDate endDate, Function<? super T, LocalDate> dateExtractor) {
        return list.stream()
                .filter(obj -> isInRange(obj, startDate, endDate, dateExtractor))
                .collect(Collectors.toList());
    }

    /**
     * 检查对象是否在指定日期范围内2
     * @param <T> 对象的类型
     * @param obj 要检查的对象
     * @param startDate 范围开始日期
     * @param endDate 范围结束日期
     * @param dateExtractor 提取日期的函数
     * @return 对象是否在日期范围内
     */
    private static <T> boolean isInRange(T obj, LocalDate startDate, LocalDate endDate, Function<? super T, LocalDate> dateExtractor) {
        LocalDate purchaseTime = dateExtractor.apply(obj);
        return purchaseTime.equals(startDate) || purchaseTime.equals(endDate) ||
                (purchaseTime.isAfter(startDate) && purchaseTime.isBefore(endDate));
    }

7.获取集合中的字段为Json，并获取对应Json中的对象属性；得到对应属性集合

   List<Integer> list = problems.stream()
                        .filter(l -> StringUtils.isNotBlank(l.getProblem())) // 过滤空问题
                        .flatMap(l -> JSON.parseArray(l.getProblem(), ProblemDTO.class).stream()) // 将字符串解析为 ProblemDTO 列表，并扁平化为单个流
                        .map(ProblemDTO::getId) // 提取 ProblemDTO 对象中的 id
                        .collect(Collectors.toList());

8.复杂数据处理，List集合先根据其中元素分组，对分组后的map的value进行过滤处理。

     List<Test> collect = list.stream()
                    .collect(Collectors.groupingBy(Test::getpId))//按pid分组得到 Map<Integer,List<Test>> map;
                    .values().stream()
                    .flatMap(group -> group.stream()
                     //对map的value根据条件过滤，保留value中List集合的元素tyep==1或（type==3并且集合中有任意一条元素的status>8）。
                            .filter(item -> item.getType() == 1||
                                    (item.getType() == 3 && group.stream().anyMatch(innerItem -> innerItem.getStatus() > 8))))
                    .collect(Collectors.toList());