Stream:常用示例

单个集合

    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);