Stream:常用示例

青旅半醒 2024-03-27 12:22 87阅读 0赞

## 单个集合 ##

List<Area> areaList = new ArrayList<>();
        Area a1 = new Area(1, 10L, "河南", new BigDecimal(100), 1);
        Area a2 = new Area(2, 20L, "江西", new BigDecimal(200), 2);
        Area a3 = new Area(3, 30L, "北京", new BigDecimal(300), 3);
        Area a4 = new Area(4, 40L, "天津", new BigDecimal(400), 1);
        areaList.add(a4);
        areaList.add(a1);
        areaList.add(a2);
        areaList.add(a3);
    
        // 集合对象某一个字段抽取出来排成集合
        List<Integer> fieldList = areaList.stream().map(item -> item.getId()).collect(Collectors.toList());
        System.out.println("集合对象某一个字段抽取出来排成集合 = " + fieldList);
    
        // 集合对象某一个字段抽取出来排成字符串
        String listObjToStr= areaList.stream().map(item -> String.valueOf(item.getId())).collect(joining(","));
        System.out.println("集合对象某一个字段抽取出来排成字符串 = " +listObjToStr);
       
        // 集合对象某一个字段抽取出来排成数组
        String[] listObjToArray = areaList.stream().map(item -> String.valueOf(item.getId())).toArray(String[]::new);
        // Long
        Long[] longs = areaList.stream().map(item -> item.getUid()).toArray(Long[]::new);
        // Integer
        Integer[] integers = areaList.stream().map(item -> item.getId()).toArray(Integer[]::new);
        System.out.println("集合对象某一个字段抽取出来排成数组 = " + listObjToArray);
    
        // 集合中对象根据String数值去重
        List<Area> uniqueList2 = areaList.stream().collect(collectingAndThen(toCollection(() -> new TreeSet<>(Comparator.comparing(Area::getName))), ArrayList::new));
        System.out.println("集合中对象去重 = " + uniqueList2);
        
        // 集合中对象根据String数值去重
        List<Area> uniqueList2 = areaList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(item -> item.getName()))), ArrayList::new));
        System.out.println("集合中对象去重 = " + uniqueList2 );
      
        // 将一个集合数据赋值带新的集合
        List<AreaVO> newList = areaList.stream().map(sg -> {
            AreaVO areaVO = BeanUtil.copyPropertes(AreaVO.class, sg);
            return areaVO;
        }).collect(Collectors.toList());
        System.out.println("将一个集合数据赋值带新的集合 = " + newList);
    
        //过滤排序出符合条件的数据
        Integer value = 10;
        List<Area> filterList = areaList.stream()
            .filter(item -> item.getUid().equals(Long.valueOf(value)))
            .filter(item -> item.getLevel() >= 2)
             .sorted(Comparator.comparing(Area::getId))//依id升序排序
            .sorted(Comparator.comparing(Area::getId).reversed())//依id降序排序
            .collect(Collectors.toList());
        System.out.println("过滤出符合条件的数据 = " + filterList);
    
        // 计算求和数量 方式1
        Integer integerTotalSum = areaList.stream().collect(summingInt(Area::getId));
        System.out.println("计算数量integerTotalSum = " + integerTotalSum);
    
        Double doubleTotalSum = areaList.stream().collect(summingDouble(Area::getId));
        System.out.println("计算数量doubleTotalSum = " + doubleTotalSum);
    
        Long longTotalSum = areaList.stream().collect(summingLong(Area::getId));
        System.out.println("计算数量longTotalSum = " + longTotalSum);
    
    
        // 计算求和数量 方式2
    
        Integer intTotalSum = areaList.stream().map(Area::getId).reduce(Integer::sum).get();
        System.out.println("计算求和数量asInteger = " + intTotalSum);
    
        Long asLong = areaList.stream().mapToLong(Area::getId).reduce(Long::sum).getAsLong();
        System.out.println("计算求和数量asLong = " + asLong);
        
        Double asDouble = areaList.stream().mapToDouble(Area::getId).reduce(Double::sum).getAsDouble();
        System.out.println("计算求和数量asDouble = " + asDouble); 
    
        // bigdecimal计算数量求和
        BigDecimal totalMoney = areaList.stream().map(Area::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
        System.out.println("bigdecimal计算数量求和 = " + totalMoney);
    
        // 求平均值
        Double avgCalories = areaList.stream().collect(averagingInt(Area::getId));
        System.out.println("求平均值 = " + avgCalories);
    
        // 集合中对象某个字段最大值对象
        Optional<Area> maxObj = areaList.stream().collect(Collectors.maxBy(Comparator.comparing(Area::getId)));
        System.out.println("集合中对象某个字段最大值对象 = " + maxObj);
    
        // 集合中对象某个字段最小值对象
        Optional<Area> minObj = areaList.stream().collect(Collectors.minBy(Comparator.comparing(Area::getId)));
        System.out.println("集合中对象某个字段最小值对象 = " + minObj);
    
        // 统计某个值全部参数
        IntSummaryStatistics summaryStatistics = areaList.stream().collect(summarizingInt(Area::getId));
        System.out.println("统计某个值全部参数 = " + summaryStatistics);
    
        // 集合对象是否符合某个条件标准
        boolean isAllAdult = areaList.stream().allMatch(item -> item.getId() > 2);
        System.out.println("集合对象是否符合某个条件标准 = " + isAllAdult);
    
        // (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2(后者数据)
        Map<Integer, Area> listToMap = areaList.stream().collect(Collectors.toMap(Area::getId, item -> item, (k1, k2) -> k1));
        Map<Integer, Area> listToLinkedHashMap = areaList.stream().collect(Collectors.toMap(Area::getId, Function.identity(), (k1, k2) -> k1, LinkedHashMap::new));
        System.out.println("根据ID,List转Map = " + listToMap);
        System.out.println("根据ID,List转Map = " + listToLinkedHashMap);
    
        //List 以level分组转化成map
        Map<Integer, List<Area>> mapByGroup = areaList.stream().collect(Collectors.groupingBy(Area::getLevel));
        System.out.println("List以level分组转化成map = " + mapByGroup);
    
        //List以level分组,求和id值
        Map<Integer, Integer> listGroupFiledSum = areaList.stream().collect(groupingBy(Area::getLevel, summingInt(Area::getId)));
        System.out.println("List以level分组,求和id值 = " + listGroupFiledSum);
        
        //单个字段，分组求和（datas）获取到sum,max,min,count
        Map<Integer, LongSummaryStatistics> enusersCollect = areaList.stream().collect(groupingBy(Area::getLevel, summarizingLong(Area::getUid)));
        System.out.println("enusersCollect = " + enusersCollect);
        
        //多个字段，分组求和（先按level分组，再按uid分组，求和id）
        Map<Integer, Map<Long, IntSummaryStatistics>> integerMapMap = areaList.stream().collect(groupingBy(Area::getLevel, groupingBy(Area::getUid, summarizingInt(Area::getId))));
        System.out.println("integerMapMap = " + integerMapMap);
    
        //List以level分组,求和money值
        Map<Integer, BigDecimal> groupFiledBigDecimalSum = areaList.stream().collect(Collectors.groupingBy(Area::getLevel, CollectorsUtil.summingBigDecimal(Area::getMoney)));
        System.out.println("groupFiledBigDecimalSum = " + groupFiledBigDecimalSum);
    
        // list以level分组,然后求每组level的最大值
        Map<Integer, Optional<Area>> listGroupMaxObj = areaList.stream().collect(groupingBy(Area::getLevel, maxBy(comparingInt(Area::getLevel))));
        System.out.println("list以level分组,然后求每组level的最大值 = " + listGroupMaxObj);
    
        // list以level分组,然后求每组level的最小值
        Map<Integer, Optional<Area>> listGroupMinObj = areaList.stream().collect(groupingBy(Area::getLevel, minBy(comparingInt(Area::getLevel))));

## 集合和集合 ##

List<String> listOne = Arrays.asList("1", "2", "3", "4", "5");
        List<String> listTwo = Arrays.asList("4", "5", "6", "7", "8");
    
        // 两个集合字符串交集
        List<String> intersection = listOne.stream().filter(item -> listTwo.contains(item)).collect(Collectors.toList());
        System.out.println("两个集合字符串交集 = " + intersection);
    
        // 两个集合字符串差集 (list1集合删除list1,list2共有的元素)
        List<String> reduce1 = listOne.stream().filter(item -> !listTwo.contains(item)).collect(Collectors.toList());
        System.out.println("listOne集合删除listOne,listTwo共有的元素后剩余元素 = " + reduce1);
    
        // 两个集合字符串差集 (list2集合删除list1,list2共有的元素)
        List<String> reduce2 = listTwo.stream().filter(item -> !listOne.contains(item)).collect(Collectors.toList());
        System.out.println("listTwo集合删除listOne,listTwo共有的元素后剩余元素 = " + reduce2);
    
        // 两个集合并集
        List<String> listAll = listOne.parallelStream().collect(Collectors.toList());
        List<String> listAll2 = listTwo.parallelStream().collect(Collectors.toList());
        listAll.addAll(listAll2);
        System.out.println("两个集合并集 = " + listAll);
    
        // 去重并集
        List<String> listAllDistinct = listAll.stream().distinct().collect(Collectors.toList());
        System.out.println("两个集合去重并集 = " + listAllDistinct);
    
        List<Area> areaListOne = new ArrayList<>();
        Area a1 = new Area(1, 10L, "河南", new BigDecimal(100), 1);
        Area a2 = new Area(2, 20L, "江西", new BigDecimal(200), 2);
        Area a3 = new Area(3, 30L, "北京", new BigDecimal(300), 3);
        Area a4 = new Area(4, 40L, "天津", new BigDecimal(400), 1);
        areaListOne.add(a4);
        areaListOne.add(a1);
        areaListOne.add(a2);
        areaListOne.add(a3);
        
        List<Area> areaListTwo = new ArrayList<>();
        Area a5 = new Area(5, 10L, "巴黎", new BigDecimal(100), 1);
        Area a6 = new Area(6, 60L, "伦敦", new BigDecimal(200), 2);
        Area a7 = new Area(7, 70L, "新西兰", new BigDecimal(300), 1);
        Area a8 = new Area(8, 80L, "悉尼", new BigDecimal(400), 2);
        areaListTwo.add(a8);
        areaListTwo.add(a5);
        areaListTwo.add(a6);
        areaListTwo.add(a7);
        
        // 两个对象获取交集
        List<Area> objIntersection = areaListOne.stream().filter(item -> areaListTwo.stream().map(e -> e.getUid()).collect(Collectors.toList()).contains(item.getUid())).collect(Collectors.toList());
        System.out.println("两个集合字符串交集 = " + objIntersection);
        
        // 两个集合字符串差集 (list1集合删除list1,list2不共有的元素)
        List<Area> differenceSet = areaListOne.stream().filter(item -> !areaListTwo.stream().map(e -> e.getUid()).collect(Collectors.toList()).contains(item.getUid())).collect(Collectors.toList());
        System.out.println("listOne集合删除listOne,listTwo共有的元素后剩余元素 = " + differenceSet);
        
        
        // 两个集合并集
        List<Area> objlistAll = areaListOne.parallelStream().collect(Collectors.toList());
        List<Area> objlist = areaListTwo.parallelStream().collect(Collectors.toList());
        objlistAll.addAll(objlist);
        System.out.println("两个集合并集 = " + objlistAll);
        
        // 去重
        List<Area> uniqueList = objlistAll.stream().collect(collectingAndThen(toCollection(() -> new TreeSet<>(comparingLong(Area::getUid))), ArrayList::new));
        System.out.println("两个集合去重并集 = " + uniqueList);