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忽略
}

lambda排序 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降序，则是使用 Comparator.comparing().reversed()，
如下所示：

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

lambda排序 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);
}

lambda排序 String类型 (过滤掉为null的属性)

错误的示例，如下：

    public static void orderStringErrorTest() {
         //设置 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);

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

可参考的写法如下：

    public static void orderString() {
         //设置 order对象属性，以下是lombok的写法，相当于 setter
        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();
        Order order5=Order.builder().age(33).weight(null).price(55.3).build();
        
        List<Order> list= new ArrayList<>();
        list.add(order1);
        list.add(order2);
        list.add(order3);
        list.add(order4);
        list.add(order5);

        //以下是倒序输出。。并且过滤掉为null的属性，避免空指针
        List<Order> orderList = list.parallelStream()
                .filter(o-> o!=null && o.getWeight()!=null)
                .sorted((o1,o2) -> new BigDecimal(o2.getWeight()).compareTo(new BigDecimal(o1.getWeight())))
                .collect(Collectors.toList());

        //升序为  .sorted(Comparator.comparing(o->new BigDecimal(o.getWeight())))        

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

lambda排序 String类型(不过滤掉null属性的排序)

如果想要将null按照 0 处理，如下所示：

    public static void orderNullToZero() {
         //设置 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();
        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(Comparator.comparing(p -> getBigDecimal(p.getWeight())))
                .collect(Collectors.toList());

//      倒序输出为 .sorted((p1,p2)-> getBigDecimal(p2.getWeight()).compareTo(getBigDecimal(p1.getWeight())) )

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

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