java8 stream sort自定義復雜排序案例

更新時間：2020年10月10日 10:48:05 作者：啃過雪糕的兔子

這篇文章主要介紹了java8 stream sort自定義復雜排序案例，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧

java 8 自定義排序

需求

今天在項目中遇到個需求，按照對象中的三個屬性進行排序。

具體要求：

前提：對象 Obj [a=a,b=b,c=c]

1、優(yōu)先級為a > b > c

2、 a屬性為中文，固定排序規(guī)則為：政府，合作，基金 … …

3、 b的為BigDecimal類型，固定的排序規(guī)則為：降序排序

4、 c為java.util.Date類型，規(guī)則為：降序排序

其實看這個需求，第3點和第4點不是什么問題，但是第1點，會考慮下怎么實現(xiàn)好。

直接上方案吧！

方案一

新建一張排序表，至少要有字段【名稱—中文名稱(政府、合作、基金等)】【排序編號—(1、2、3)】，在Obj表中的a字段存排序表的id。

此時可以直接用sql語句 ORDER BY 排序即可。

優(yōu)點：可動態(tài)配置。

方案二

完全用java代碼操作，和sql無關(guān)，上代碼：

Obj.java 和 Sort.java

package TestSort;
import java.math.BigDecimal;
public class Obj {
 private String name;
 private BigDecimal price;
 public Obj(String name, BigDecimal price){
 this.name = name;
 this.price = price;
 }
 
 public Obj(){
 
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public BigDecimal getPrice() {
 return price;
 }
 public void setPrice(BigDecimal price) {
 this.price = price;
 }
 @Override
 public String toString() {
 return "Obj [name=" + name + ", price=" + price + "]";
 } 
}

package TestSort;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
public class Sort {
 
 public static void main(String[] args) {
 List<Obj> list = Arrays.asList(
  new Obj("政府", null),
  new Obj("政府", new BigDecimal("1216.23")),
  new Obj("商業(yè)", new BigDecimal("123.23")),
  new Obj("PPD", new BigDecimal("123.23")),
  new Obj("合作", new BigDecimal("127.23")),
  new Obj("合作", new BigDecimal("125.23")),
  new Obj("咨詢", null),
  new Obj(null, null)
  );
 
 /*Comparator<Obj> byName = Comparator.comparing(Obj::getName).reversed();
 
 Comparator<Obj> finalByPrice= byName.thenComparing(Obj::getPrice,Comparator.nullsFirst(BigDecimal::compareTo)).reversed();
 
 List<Obj> result = list.stream().filter(new Predicate<Obj>() {
    @Override
    public boolean test(Obj obj) {
    if(obj.getName() == null && obj.getPrice() ==null){
     return false;
    }
    return true;
    }
   }).sorted(finalByPrice).collect(Collectors.toList());*/
 
 List<Obj> result = list.stream().sorted(
     //先按照name排序（模擬需求的a屬性排序）
  Comparator.comparing(Obj::getName,(x,y)->{
   if(x == null && y != null){
   return 1;
   }else if(x !=null && y == null){
   return -1;
   }else if(x == null && y == null){
   return -1;
   }else if("PPD".equals(x) || "PPD".equals(y)){
   if(x.equals(y)){
    return 0;
   }else if("PPD".equals(x)){
    return -1;
   }else{
    return 1;
   }
   }else
   if("合作".equals(x) || "合作".equals(y)){
   if(x.equals(y)){
    return 0;
   }else if("合作".equals(x)){
    return -1;
   }else{
    return 1;
   }
   }else
   if("政府".equals(x) || "政府".equals(y)){
   if(x.equals(y)){
    return 0;
   }else if("政府".equals(x)){
    return -1;
   }else{
    return 1;
   }
   }
   return 0; })
     //再按照其他字段排序，要考慮null（模擬需求b和c字段排序）
     .thenComparing(Comparator.comparing(Obj::getPrice,
     Comparator.nullsFirst(BigDecimal::compareTo)).reversed()
  )).collect(Collectors.toList());
 System.out.println(result);
 System.out.println(result.size());
 }
 }

方案二的缺點就是硬編碼，用戶改排序就得改源碼。對第二種方案的改進：

package TestSort;
 
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
 
public class Sort {
 public static void main(String[] args) {
 List<Obj> list = Arrays.asList(
  new Obj("政府", null),
  new Obj("政府", new BigDecimal("1216.23")),
  new Obj("商業(yè)", new BigDecimal("123.23")),
  new Obj("PPD", new BigDecimal("123.23")),
  new Obj("合作", new BigDecimal("127.23")),
  new Obj("合作", new BigDecimal("125.23")),
  new Obj("咨詢", null),
  new Obj(null, null)
  );
 /*Comparator<Obj> byName = Comparator.comparing(Obj::getName).reversed();
 Comparator<Obj> finalByPrice= byName.thenComparing(Obj::getPrice,Comparator.nullsFirst(BigDecimal::compareTo)).reversed();
 List<Obj> result = list.stream().filter(new Predicate<Obj>() {
    @Override
    public boolean test(Obj obj) {
    if(obj.getName() == null && obj.getPrice() ==null){
     return false;
    }
    return true;
    }
   }).sorted(finalByPrice).collect(Collectors.toList());*/
 //此處模擬從數(shù)據(jù)讀取配置到list
 List<String> sortList = Arrays.asList("PPD","政府","合作");
 list.stream().sorted(
  Comparator.comparing(Obj::getName,(x,y)->{
   if(x == null && y != null){
   return 1;
   }else if(x !=null && y == null){
   return -1;
   }else if(x == null && y == null){
   return -1;
   }else{
   //按照讀取的list順序排序
   for(String sort : sortList){
    if(sort.equals(x) || sort.equals(y)){
    if(x.equals(y)){
     return 0;
    }else if(sort.equals(x)){
     return -1;
    }else{
     return 1;
    }
    }
   }
   return 0;
   }
  }).thenComparing(Comparator.comparing(Obj::getPrice,Comparator.nullsFirst(BigDecimal::compareTo)).reversed())
  ).collect(Collectors.toList()).forEach(System.out::println);;
 }
 }

補充知識：java8 stream代替for循環(huán) sort多字段排序 group by多級排序

我就廢話不多說了，大家還是直接看代碼吧`

List<MacTicket> list = new ArrayList();
Category ctg= new Category();
ctg.setType(1);//0商品，1銷售規(guī)格
ctg.setSort(2);
ctg.setInheritFlag(0);//0繼承屬性1非繼承屬性
ctg.setValueSort(1)
Category ctg1= new Category();
ctg1.setType(0);//0商品，1銷售規(guī)格
ctg1.setSort(1);
ctg1.setInheritFlag(1);//0繼承屬性1非繼承屬性
ctg1.setValueSort(2)
list.add(ctg);
list.add(ctg1);
        lista.stream().sorted(Comparator.comparing(Category::getSort()).thenComparing(Category::getValueSort())).collect(Collectors.groupingBy(fetchGroupInheritKey(mtg)),Collectors.groupingBy(fetchGroupTypeKey(mtg)));
private String fetchGroupInheritKey(Category ctg){
        if(inheritFlag==0){
          return "inheritList";
        }else if(inheritFlag==1){
          return "ownList";
        }else{
          return "";
        }
        
      }

使用Comparator實現(xiàn)多字段排序和多級分組，前面的sort排序會影響后面的groupBy分組后的list中的排序

mcvo中有有多個property List ，按商品屬性和銷售屬性區(qū)分將多個小list聚合為一個list