java8的stream操作集合常用姿势

原文地址:
java极客技术stream

无状态指:元素处理不受之前元素影响
有状态:只有拿到所有的元素才能继续下去
非短路:处理完所有结果才能得到最终结果
短路:符合某些条件可得到记过

并行流

list.parallelStram()； 并行流会改变其中元素顺序，内部是以多线程进行操作 最终合并每个处理结果
顺序流转成并行流可以通过parallel()方法

获取流的静态方法

Stram.of(1，2,3，5)
Stram.genrate（Math::random）

1 获取对象集合的某个属性集合

List<Integer>orderIds = list.stream().map(chargeOrder -> chargeOrder.getId()).collect(Collectors.toList());

2 过滤掉一些值（满足条件的才会保留）

list.stream().filter(chargeOrderDTO -> chargeOrderDTO.getStatus() != 0 && chargeOrderDTO.getStatus() != 2).collect(Collectors.toList());
获取最大，最小，数量
count()
max()
min()

3 去重（某个属性一样的只保留一个）

distinct() 适合简单类型的集合

 List<ChargeOrderDTO> drUserList = list.stream().collect(
                collectingAndThen(toCollection(() -> new TreeSet<>(comparing(ChargeOrderDTO::getDrUserId))), ArrayList::new));

4 分组求和（double会丢精度）

   Map<Integer, Double> map = filterChargeOrderItemList.stream()
                .collect(Collectors.groupingBy(ChargeOrderItemDO::getPrescriptionId, Collectors.summingDouble(ChargeOrderItemDO::getFeeAmount)));

5求和

 Double prescriptionTotalAmt = chargeOrderItemList.stream().collect(Collectors.summingDouble(ChargeOrderItemDO::getFeeAmount));

 BigDecimal totalFee = list.stream().map(dataMap -> new BigDecimal( dataMap.get("feeAmt").toString())).reduce(BigDecimal.ZERO, (a, b) -> {
            if (a == null || b == null) {
                return BigDecimal.ZERO;
            }
            return a.add(b);
        });

BigDecimal sumFee=new BigDecimal(list.stream().mapToDouble(doposit-> MapUtil.getDouble(doposit,"payAmt",new Double(0))).sum());

5 map迭代

  Iterator it=groupMap.entrySet().iterator();
                        while(it.hasNext()) {
                            Map.Entry entry=(Map.Entry) it.next();
                             String key=entry.getKey().toString();
                              };
                             	

        map.forEach((k, v) -> {
            System.out.println(k + " = " + v.toString());
        });
        Collection<Double> valueSet = map.values();
        BigDecimal max=new BigDecimal(Collections.max(valueSet));
        BigDecimal min=new BigDecimal(Collections.min(valueSet));

6 按照多个字段分组归类

 //定义分组集合Map
                Map<String, List<Map>> groupMap = new HashMap<>();
                for (Map dataMap : feePackageItems) {
                    String packageName = MapUtil.getString(dataMap, "feePackageName");
                    //套餐名分组
                    String key=packageName;
                    if (groupMap.containsKey(key)) {
                        List<Map> list = groupMap.get(key);
                        list.add(dataMap);
                        groupMap.put(key, list);
                    } else {
                        List<Map> groupItemList = new ArrayList<>();
                        groupItemList.add(dataMap);
                        groupMap.put(key, groupItemList);
                    }
          }

7遍历/匹配

Optional 类
使用  of() 和 ofNullable() 方法创建包含值的 Optional。
检查是否有值ifPresent() 

匹配第一个
findFist()
匹配任意
findAny(）适合并行流
boolean xx=list.stream.anyMatch(X->X<6)

8字符串全部大写

list.forEach（t->t.toUpperCase）

9 collect的方法

maxBy
minBy
summingInt
summingDouble
summarizingLong统计以上所有


/** * 统计员工人数、平均工资、工资总额、最高工资 */
private static void test01(){ 
//统计员工人数 Long count = personList.stream().collect(Collectors.counting()); 
//求平均工资 Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary)); 
//求最高工资 Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
 //求工资之和 Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary)); 
 //一次性统计所有信息 DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary)); 
 System.out.println("统计员工人数:"+count); 
 System.out.println("求平均工资:"+average);
  System.out.println("求最高工资:"+max); 
  System.out.println("求工资之和:"+sum); 
  System.out.println("一次性统计所有信息:"+collect);}

10 排序

private static void test04(){ // 按工资升序排序（自然排序）
 List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName) .collect(Collectors.toList()); 
 // 按工资倒序排序 List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed()) .map(Person::getName).collect(Collectors.toList()); // 先按工资再按年龄升序排序 List<String> newList3 = personList.stream() .sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName) .collect(Collectors.toList()); 
  // 先按工资再按年龄自定义排序（降序） List<String> newList4 = personList.stream().sorted((p1, p2) -> { if (p1.getSalary() == p2.getSalary()) { return p2.getAge() - p1.getAge(); } else { return p2.getSalary() - p1.getSalary(); } }).map(Person::getName).collect(Collectors.toList());

11 limit ，skip，读取文件onClose，contains差集