java8streamsort自定义复杂排序案例

java8streamsort⾃定义复杂排序案例
java 8 ⾃定义排序
需求
今天在项⽬中遇到个需求，按照对象中的三个属性进⾏排序。

具体要求：
前提：对象 Obj [a=a,b=b,c=c]
1、优先级为a > b > c
2、 a属性为中⽂，固定排序规则为：政府，合作，基⾦ … …
3、 b的为BigDecimal类型，固定的排序规则为：降序排序
4、 c为java.util.Date类型，规则为：降序排序
其实看这个需求，第3点和第4点不是什么问题，但是第1点，会考虑下怎么实现好。

直接上⽅案吧！
⽅案⼀
新建⼀张排序表，⾄少要有字段【名称—中⽂名称(政府、合作、基⾦等)】【排序编号—(1、2、3)】，在Obj表中的a字段存排序表的id。

此时可以直接⽤sql语句 ORDER BY 排序即可。

优点：可动态配置。

⽅案⼆
完全⽤java代码操作，和sql⽆关，上代码：
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){
= name;
this.price = price;
}
public Obj(){
}
public String getName() {
return name;
}
public void setName(String 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 parator;
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("商业", 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 = paring(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属性排序）
paring(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(paring(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 parator;
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("商业", 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 = paring(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
List<String> sortList = Arrays.asList("PPD","政府","合作");
list.stream().sorted(
paring(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(paring(Obj::getPrice,Comparator.nullsFirst(BigDecimal::compareTo)).reversed())
).collect(Collectors.toList()).forEach(System.out::println);;
}
}
补充知识：java8 stream代替for循环 sort多字段排序 group by多级排序
我就废话不多说了，⼤家还是直接看代码吧`
List<MacTicket> list = new ArrayList();
Category ctg= new Category();
ctg.setType(1);//0商品，1销售规格
ctg.setSort(2);
ctg.setInheritFlag(0);//0继承属性1⾮继承属性
ctg.setValueSort(1)
Category ctg1= new Category();
ctg1.setType(0);//0商品，1销售规格
ctg1.setSort(1);
ctg1.setInheritFlag(1);//0继承属性1⾮继承属性
ctg1.setValueSort(2)
list.add(ctg);
list.add(ctg1);
lista.stream().sorted(paring(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实现多字段排序和多级分组，前⾯的sort排序会影响后⾯的groupBy分组后的list中的排序
mcvo中有有多个property List ，按商品属性和销售属性区分将多个⼩list聚合为⼀个list
mc V o list.stream(). flat Map(mc vo→mcvo.getPropertyList(). stream ())
以上这篇java8 stream sort⾃定义复杂排序案例就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。