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

@Data

         class Student{

             public Integer age;

             public String name;

             public String sex;

         }

         List<Student> 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<Student> result = students.stream().filter(student -> student.getSex().equals( "女" )).collect(Collectors.toList());

         System.out.println(result);

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测试数据paring(Order::getNum))), ArrayList:: new ));

// 按照订单编号和类型去重

orders = orders.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(()

          -> new TreeSet<>(Comparator测试数据paring(o -> o.getNum() + ";" + o.getType()))), ArrayList:: new ));

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()测试数据pareTo(o1.getAllAmt())));

   // 方式二

   orders.sort(Comparator测试数据paring(Order::getAllAmt, (o1, o2)

          -> o1 == null ? 1 : (o2 == null ? - 1 : o2测试数据pareTo(o1))));

   // 方式三 (allAmt 字段不能为 null， null 会导致排序失败)

   orders.sort(Comparator测试数据paring(Order::getAllAmt).reversed());

   // 先按照订单类型排序，再按照订单应付金额从高到低排序

   orders.sort(Comparator测试数据paring(Order::getType, (o1, o2)

          -> o1 == null ? 1 : (o2 == null ? - 1 : o1测试数据pareTo(o2))).thenComparing((o1, o2)

          -> o1.getPayAmt() == null ? 1 : (o2.getPayAmt() == null ? - 1 : o2.getPayAmt()测试数据pareTo(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();