lambda排序sorted

lambda排序sorted

lambda排序sorted，基本的格式如下：

  list.parallelStream()
      .filter()
      .sorted(Comparator.comparing())
      .collect(Collectors.toList());

parallelStream是并行流，线程不安全，使用collect会变得线程安全。

filter()用于筛选数据，

sorted()是排序，Comparator.comparing()是排序用的比较器。

int类型、double、String类型的排序方式， 稍微有些不同，具体的示例如下。

pojo类：

public class Order {

    private String weight;

    private double price;

    private int age ;

    //getter和setter忽略
}

int类型的属性排序：

按照age升序如下所示：

    public static void orderInt() {
        //设置 order对象属性，以下是lombok的写法，相当于 setter
        Order order1=Order.builder().age(10).weight("66.5").price(33.6).build();
        Order order2=Order.builder().age(2).weight("19.5").price(1.3).build();
        Order order3=Order.builder().age(66).weight("100.5").price(55.8).build();
        Order order4=Order.builder().age(33).weight("5.43").price(55.3).build();
        List<Order> list= new ArrayList<>();
        list.add(order1);
        list.add(order2);
        list.add(order3);
        list.add(order4);


        //.filter(Objects::nonNull)表示筛选出不为null的对象。    
        List<Order> orderList = list.parallelStream()
                .filter(Objects::nonNull)
                .sorted(Comparator.comparing(Order::getAge))
                .collect(Collectors.toList());

        orderList.forEach(System.out::println);
    }

如果想要按照int降序，则是：

  List<Order> orderList = list.parallelStream()
          .filter(Objects::nonNull)
          .sorted(Comparator.comparing(Order::getAge).reversed())
          .collect(Collectors.toList());

double类型属性的排序：

    public static void orderDouble() {
         //设置 order对象属性，以下是lombok的写法，相当于 setter
        Order order1=Order.builder().age(10).weight("66.5").price(33.3).build();
        Order order2=Order.builder().age(2).weight("19.5").price(1.3).build();
        Order order3=Order.builder().age(66).weight("100.5").price(55.3).build();
        Order order4=Order.builder().age(33).weight("5.43").price(55.3).build();
        List<Order> list= new ArrayList<>();
        list.add(order1);
        list.add(order2);
        list.add(order3);
        list.add(order4);

        List<Order> orderList = list.parallelStream()
                .filter(Objects::nonNull)
                .sorted(Comparator.comparing(o -> new BigDecimal(String.valueOf(o.getPrice()))))
                .collect(Collectors.toList());
        orderList.forEach(System.out::println);
}

String类型属性的排序

错误的示例，如下：

    public static void orderStringErrorTest() {
        Order order1=Order.builder().age(10).weight("66.5").price(33.3).build();
        Order order2=Order.builder().age(2).weight("19.5").price(1.3).build();
        Order order3=Order.builder().age(66).weight("100.5").price(55.3).build();
        Order order4=Order.builder().age(33).weight("5.43").price(55.3).build();
        List<Order> list= new ArrayList<>();
        list.add(order1);
        list.add(order2);
        list.add(order3);
        list.add(order4);

        //由于是String类型，直接排序是按字典排序，并不是按数值大小排序。。以下排序结果，明显是错误的。。
        //字典排序，就是从第一个字符开始比较，相同则比较第二个字符。所以会出现 "100"小于"2"的情况
        List<Order> orderList = list.stream().sorted(Comparator.comparing(Order::getWeight)).collect(Collectors.toList());
        orderList.forEach(System.out::println);
    }

可参考的写法如下：

    public static void orderString() {
        Order order1=Order.builder().age(10).weight("-0.05").price(33.3).build();
        Order order2=Order.builder().age(2).weight("-0.01").price(1.3).build();
        Order order3=Order.builder().age(66).weight("100.5").price(55.3).build();
        Order order4=Order.builder().age(33).weight("-5.43").price(55.3).build();
        List<Order> list= new ArrayList<>();
        list.add(order1);
        list.add(order2);
        list.add(order3);
        list.add(order4);

        //升序为  .sorted(Comparator.comparing(o->new BigDecimal(o.getWeight())))        
        //以下是倒序输出。。
        List<Order> orderList = list.parallelStream()
                .filter(Objects::nonNull)
                .sorted((o1,o2) -> new BigDecimal(o2.getWeight()).compareTo(new BigDecimal(o1.getWeight())))
                .collect(Collectors.toList());
        orderList.forEach(System.out::println);
      }

String类型属性，不过滤掉null属性的排序

以上的String类型属性排序，都是把null过滤掉的，如果想要将null按照 0 处理，如下所示：

    public static void orderNullToZero() {
        Order order1=Order.builder().age(10).weight("66.5").price(33.3).build();
        Order order2=Order.builder().age(2).weight("19.5").price(1.3).build();
        Order order3=Order.builder().age(66).weight("100.5").price(55.3).build();
        Order order4=Order.builder().age(33).weight("5.43").price(55.3).build();
        Order order5=Order.builder().age(33).weight(null).price(55.3).build();
        Order order6=Order.builder().age(33).weight("-3").price(55.3).build();
        List<Order> list= new ArrayList<>();
        list.add(order1);
        list.add(order2);
        list.add(order3);
        list.add(order4);
        list.add(order5);
        list.add(order6);

//      这个是倒序输出
//        List<Order> orderList = list.parallelStream()
//                .filter(Objects::nonNull)
//                .sorted((p1,p2)-> getBigDecimal(p2.getWeight()).compareTo(getBigDecimal(p1.getWeight())) )
//                .collect(Collectors.toList());

       // 这个是升序输出
        List<Order> orderList = list.parallelStream()
                .filter(Objects::nonNull)
                .sorted(Comparator.comparing(p -> getBigDecimal(p.getWeight())))
                .collect(Collectors.toList());

        orderList.forEach(System.out::println);


    }

    public static BigDecimal getBigDecimal(String num) {
        return num == null? BigDecimal.ZERO : new BigDecimal(num);
    }

lambda排序sorted

原文：https://www.cnblogs.com/expiator/p/14265123.html