java8如何根据list对象中的属性过滤筛选

根据list对象中的属性过滤筛选

代码演示:

根据性别筛选出所有的女同学

@Data
        class Student{
            public Integer age;
            public String name;
            public String sex;
        }
        List students = new ArrayList<>();
        Student student1 = new Student();
        student1.setAge(18);
        student1.setName("赵");
        student1.setSex("男");
        Student student2 = new Student();
        student2.setAge(19);
        student2.setName("钱");
        student2.setSex("女");
        Student student3 = new Student();
        student3.setAge(20);
        student3.setName("孙");
        student3.setSex("女");
        Collections.addAll(students,student1,student2,student3);
        //根据条件过滤 出所有的女同学
        List result = students.stream().filter(student -> student.getSex().equals("女")).collect(Collectors.toList());
        System.out.println(result);

执行结果:

filter方法:

对流的过滤,将一个流转换成另一个子集流

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

我们利用 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 orders = Lists.newArrayList();
  
// 筛选总金额大于1000的订单
orders = orders.stream().filter(item -> item.getAllAmt() > 1000.00f).collect(Collectors.toList());

分组

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

去重

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

排序

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

以上为个人经验,希望能给大家一个参考,也希望大家多多支持脚本之家。

你可能感兴趣的