java8 List 根据对象某个字段或多个字段去重、筛选、List转Map、排序、分组、统计计数等等

刺骨的言语ヽ痛彻心扉 2022-04-24 08:34 546阅读 0赞

我们利用 java8 的新特性，可以方便简洁高效的处理一些集合的数据。  
简单示例如下：  
先定义一个订单对象（Order）

public class Order { 
    
        private Long id;
        private Long userId;
        private String num;
        private String type;
        private Float allAmt;
        private Float payAmt;
        private Integer orderNum;
    
        public Order(Long id, Long userId, String num, String type, Float allAmt, Float payAmt, Integer orderNum) { 
            this.id = id;
            this.userId = userId;
            this.num = num;
            this.type = type;
            this.allAmt = allAmt;
            this.payAmt = payAmt;
            this.orderNum = orderNum;
        }
        // getting... setting...
    }

过滤筛选：

List<Order> orders = Lists.newArrayList();
      
      // 筛选总金额大于1000的订单
      orders = orders.stream().filter(item -> item.getAllAmt() > 1000.00f).collect(Collectors.toList());

分组：

List<Order> orders = Lists.newArrayList();
      
      // 按照订单类型分组
      Map<String, List<Order>> orderGroupMap = orders.stream().collect(Collectors.groupingBy(Order::getType));

去重：

List<Order> orders = Lists.newArrayList();
      
      // 按照订单编号去重
      orders = orders.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(()
              -> new TreeSet<>(Comparator.comparing(Order::getNum))), ArrayList::new));
    
      // 按照订单编号和类型去重
      orders = orders.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(()
              -> new TreeSet<>(Comparator.comparing(o -> o.getNum() + ";" + o.getType()))), ArrayList::new));

List 转 Map ：

List<Order> orders = Lists.newArrayList();
      
      // 将订单集合转换成订单编号-应付金额 map，注意订单编号作为 key 不能重复，应先做去重处理
      Map<String, Float> numPayMap = orders.stream().collect(Collectors.toMap(Order::getNum, Order::getPayAmt));
    
      // 用 id 做 key 将 List 转成 Map
      Map<Long, Order> orderMap = orders.stream().collect(Collectors.toMap(Order::getId, item -> item));

排序：

List<Order> orders = Lists.newArrayList();
      
      // 按照订单总金额从高到低排序
      // 方式一
      orders.sort((o1, o2)
              -> o1.getAllAmt() == null ? 1 : (o2.getAllAmt() == null ? -1 : o2.getAllAmt().compareTo(o1.getAllAmt())));
    
      // 方式二
      orders.sort(Comparator.comparing(Order::getAllAmt, (o1, o2)
              -> o1 == null ? 1 : (o2 == null ? -1 : o2.compareTo(o1))));
    
      // 方式三 (allAmt 字段不能为 null， null 会导致排序失败)
      orders.sort(Comparator.comparing(Order::getAllAmt).reversed());
    
      // 先按照订单类型排序，再按照订单应付金额从高到低排序
      orders.sort(Comparator.comparing(Order::getType, (o1, o2)
              -> o1 == null ? 1 : (o2 == null ? -1 : o1.compareTo(o2))).thenComparing((o1, o2)
              -> o1.getPayAmt() == null ? 1 : (o2.getPayAmt() == null ? -1 : o2.getPayAmt().compareTo(o1.getPayAmt()))));

统计计数：

List<Order> orders = Lists.newArrayList();
      
      // 统计所有订单的总金额
      // 求和
      Double sum = orders.stream().filter(item -> item.getAllAmt() != null).mapToDouble(Order::getAllAmt).sum();
    
      // 最大总金额
      OptionalDouble max = orders.stream().filter(item -> item.getAllAmt() != null).mapToDouble(Order::getAllAmt).max();
      // 防止没有订单数据的处理
      Double maxAllAmt = max.isPresent() ? max.getAsDouble() : 0;
      
      // 最小总金额
      OptionalDouble min = orders.stream().filter(item -> item.getAllAmt() != null).mapToDouble(Order::getAllAmt).min();
    
      // 平均总金额
      OptionalDouble average = orders.stream().filter(item -> item.getAllAmt() != null).mapToDouble(Order::getAllAmt).average();