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);
    }