List的多维度排序案例演示~
文章也已同步到我的csdn：http://blog.csdn.net/u012881584/article/details/72377510
关于List的多维度排序。
日常工作中有很多关于list的排序功能， 看到公司封装的一个比较好的工具类， 这里拿来记录学习下。
public class SortBuilder<T> {
// Never make these public
static final int LEFT_IS_GREATER = 1;
static final int RIGHT_IS_GREATER = -1;
private static final Logger log = LoggerFactory.getLogger(SortBuilder.class);
private List<SortFiled<T>> sortFileds = Lists.newLinkedList();
private Map<String, Method> propertyMethodMap = null;
private boolean nullsFirst;
private boolean nullsLast;
private boolean zerosFirst;
private boolean zerosLast;
private boolean natural;
private Direction naturalDirection;
private SortBuilder() {
}
public static <C> SortBuilder<C> newBuilder(Class clazz) {
SortBuilder<C> sortBuilder = new SortBuilder<>();
PropertyDescriptor[] propertyDescriptor = BeanUtils.getPropertyDescriptors(clazz);
Map<String, Method> propertyMethodMap = new HashMap<>();
for (PropertyDescriptor pd : propertyDescriptor) {
String key = pd.getName();
Method value = pd.getReadMethod();
propertyMethodMap.put(key, value);
}
sortBuilder.propertyMethodMap = propertyMethodMap;
return sortBuilder;
}
/**
* null 排序到最前面
*/
public SortBuilder<T> nullsFirst() {
nullsFirst = true;
nullsLast = false;
return this;
}
/**
* null 排序到最后面
*/
public SortBuilder<T> nullsLast() {
nullsFirst = false;
nullsLast = true;
return this;
}
/**
* 0 排序到最后面
*/
public SortBuilder<T> zerosLast() {
zerosFirst = false;
zerosLast = true;
return this;
}
/**
* 0 排序到最前面
*/
public SortBuilder<T> zerosFirst() {
zerosFirst = true;
zerosLast = false;
return this;
}
/**
* 自然排序 {1,5,3,2,4} = {1,2,3,4,5}
*/
public SortBuilder<T> natural() {
natural = true;
return this;
}
/**
* 自然排序 {1,5,3,2,4} = {1,2,3,4,5}
*/
public SortBuilder<T> natural(Direction direction) {
natural = true;
naturalDirection = direction;
return this;
}
public SortBuilder<T> clear() {
sortFileds.clear();
return this;
}
/**
* 增加一个降序
*
* @param fieldName 属性
*/
public SortBuilder<T> addDesc(String fieldName) {
addFieldMethod(fieldName, Direction.DESC);
return this;
}
/**
* 增加一个自定义排序
*
* @param comparator 自定义比较器
*/
public SortBuilder<T> addCustom(Comparator<T> comparator) {
sortFileds.add(SortFiled.builder(Direction.CUSTOM, null, comparator));
return this;
}
/**
* 增加一个升序
*
* @param fieldName 属性
*/
public SortBuilder<T> addAsc(String fieldName) {
addFieldMethod(fieldName, Direction.ASC);
return this;
}
/**
* 增加一个字段排序模式
*
* @param fieldName 属性
* @param direction 排序方式
*/
private SortBuilder<T> addFieldMethod(String fieldName, Direction direction) {
Method method = propertyMethodMap.get(fieldName);
if (method == null) {
log.error("NoSuchMethodException field:{}", fieldName);
} else {
sortFileds.add(SortFiled.<T>builder(direction, method, null));
}
return this;
}
public SortBuilder<T> sortList(List<T> list) {
Collections.sort(list, buildComparator());
return this;
}
private Comparator<T> buildComparator() {
return new Comparator<T>() {
public int compare(T o1, T o2) {
int flag = 0;
if (sortFileds.size() == 0 && natural) {
flag = compareNatural(o1, o2, naturalDirection);
} else {
for (SortFiled<T> sortFiled : sortFileds) {
Method method = sortFiled.getMethod();
Direction direction = sortFiled.getDirection();
if (direction == Direction.CUSTOM) {
flag = sortFiled.getComparator().compare(o1, o2);
} else {
flag = this.compare(method, o1, o2, direction);
}
if (flag != 0) {
break;
}
}
}
return flag;
}
private int compare(Method method, T left, T right, Direction direction) {
int flag = 0;
try {
Object leftVal = method.invoke(left);
Object rightVal = method.invoke(right);
Class returnType = method.getReturnType();
if (nullsFirst) {
flag = compareNulls(returnType, leftVal, rightVal, false, direction);
} else if (nullsLast) {
flag = compareNulls(returnType, rightVal, leftVal, true, direction);
} else {
flag = compare(returnType, leftVal, rightVal, direction);
}
} catch (IllegalArgumentException | IllegalAccessException | InvocationTargetException e) {
e.printStackTrace();
}
return flag;
}
private int compareNatural(Object leftVal, Object rightVal, Direction direction) {
int flag;
if (nullsFirst) {
flag = compareNulls(leftVal, rightVal, false, direction);
} else if (nullsLast) {
flag = compareNulls(rightVal, leftVal, true, direction);
} else {
flag = compare(leftVal.getClass(), leftVal, rightVal, direction);
}
return flag;
}
private int compareNulls(Object leftVal, Object rightVal, boolean reverse, Direction direction) {
return compareNulls(leftVal == null ? null : leftVal.getClass(), leftVal, rightVal, reverse, direction);
}
private int compareNulls(Class returnType, Object leftVal, Object rightVal, boolean reverse,
Direction direction) {
if (leftVal == rightVal) {
return 0;
} else if (leftVal == null) {
return RIGHT_IS_GREATER;
} else if (rightVal == null) {
return LEFT_IS_GREATER;
} else {
return reverse ? compare(returnType, rightVal, leftVal, direction) : compare(returnType, leftVal,
rightVal, direction);
}
}
private int compareZeros(BigDecimal leftNumber, BigDecimal rightNumber, boolean reverse, Direction direction) {
if (leftNumber.compareTo(rightNumber) == 0) {
return 0;
} else if (leftNumber.compareTo(BigDecimal.valueOf(0)) == 0) {
return RIGHT_IS_GREATER;
} else if (rightNumber.compareTo(BigDecimal.valueOf(0)) == 0) {
return LEFT_IS_GREATER;
} else {
return reverse ? compareNumber(rightNumber, leftNumber, direction) : compareNumber(leftNumber,
rightNumber, direction);
}
}
private int compareNumber(BigDecimal leftNumber, BigDecimal rightNumber, Direction direction) {
if (leftNumber.compareTo(rightNumber) == 0) {
return 0;
} else {
return direction == null || direction == Direction.ASC ? leftNumber.compareTo(rightNumber)
: rightNumber.compareTo(leftNumber);
}
}
private int compare(Class returnType, Object leftVal, Object rightVal, Direction direction) {
int flag;
if (Number.class.isAssignableFrom(returnType) || returnType == int.class || returnType == long.class
|| returnType == double.class || returnType == float.class) {
BigDecimal leftNumber = BigDecimal.valueOf(Double.valueOf(leftVal.toString()));
BigDecimal rightNumber = BigDecimal.valueOf(Double.valueOf(rightVal.toString()));
if (zerosFirst) {
flag = compareZeros(leftNumber, rightNumber, false, direction);
} else if (zerosLast) {
flag = compareZeros(rightNumber, leftNumber, true, direction);
} else {
flag = compareNumber(leftNumber, rightNumber, direction);
}
} else {
String methodReturn1 = leftVal.toString();
String methodReturn2 = rightVal.toString();
if (direction == null || direction == Direction.ASC) {
flag = methodReturn1.compareTo(methodReturn2);
} else {
flag = methodReturn2.compareTo(methodReturn1);
}
}
return flag;
}
};
}
/**
* 排序方式：
* <p/>
* ASC:升序,DESC:降序
*/
public enum Direction {
ASC, DESC, CUSTOM
}
static class SortFiled<T> {
private Method method;
private Direction direction;
private Comparator<T> comparator;
SortFiled(Direction direction, Method method, Comparator<T> comparator) {
this.method = method;
this.direction = direction;
this.comparator = comparator;
}
@SuppressWarnings("unchecked")
public static <T> SortFiled<T> builder(Direction direction, Method method, Comparator<T> comparator) {
return new SortFiled(direction, method, comparator);
}
public Method getMethod() {
return method;
}
public void setMethod(Method method) {
this.method = method;
}
public Direction getDirection() {
return direction;
}
public void setDirection(Direction direction) {
this.direction = direction;
}
public Comparator<T> getComparator() {
return comparator;
}
public void setComparator(Comparator<T> comparator) {
this.comparator = comparator;
}
}
}
使用方法：
@Autowired
private SeriesDiagramEntityService seriesDiagramEntityService;
@org.junit.Test
public void testSortBuilder() throws Exception{
List<SeriesDiagramEntity> list = seriesDiagramEntityService.findAll(SeriesDiagramEntity.Fields.status.eq(CommonConstants.DataStatus.PUBLISH).limit(1000));
SortBuilder.<SeriesDiagramEntity>newBuilder(SeriesDiagramEntity.class).addAsc("source").addAsc("displayOrder").addDesc("status").sortList(list);
}
使用起来很简单，我们这里写了个unit test来演示。 原理就是直接使用JavaBean中的属性进行asc或者desc的排序展示。
下面来看看它是具体怎么运行的：
- 首先获取到实体类的属性， 然后添加到propertyMethodMap中。
PropertyDescriptor[] propertyDescriptor = BeanUtils.getPropertyDescriptors(clazz);
- 然后是将用户自定义的排序字段加入到sortFileds中去：
/**
* 增加一个升序
*
* @param fieldName 属性
*/
public SortBuilder<T> addAsc(String fieldName) {
addFieldMethod(fieldName, Direction.ASC);
return this;
}
/**
* 增加一个字段排序模式
*
* @param fieldName 属性
* @param direction 排序方式
*/
private SortBuilder<T> addFieldMethod(String fieldName, Direction direction) {
Method method = propertyMethodMap.get(fieldName);
if (method == null) {
log.error("NoSuchMethodException field:{}", fieldName);
} else {
sortFileds.add(SortFiled.<T>builder(direction, method, null));
}
return this;
}
- 进行排序
public SortBuilder<T> sortList(List<T> list) {
Collections.sort(list, buildComparator());
return this;
}
private Comparator<T> buildComparator() {
return new Comparator<T>() {
public int compare(T o1, T o2) {
int flag = 0;
if (sortFileds.size() == 0 && natural) {
flag = compareNatural(o1, o2, naturalDirection);
} else {
for (SortFiled<T> sortFiled : sortFileds) {
Method method = sortFiled.getMethod();
Direction direction = sortFiled.getDirection();
if (direction == Direction.CUSTOM) {
flag = sortFiled.getComparator().compare(o1, o2);
} else {
flag = this.compare(method, o1, o2, direction);
}
if (flag != 0) {
break;
}
}
}
return flag;
}
private int compare(Method method, T left, T right, Direction direction) {
int flag = 0;
try {
Object leftVal = method.invoke(left);
Object rightVal = method.invoke(right);
Class returnType = method.getReturnType();
if (nullsFirst) {
flag = compareNulls(returnType, leftVal, rightVal, false, direction);
} else if (nullsLast) {
flag = compareNulls(returnType, rightVal, leftVal, true, direction);
} else {
flag = compare(returnType, leftVal, rightVal, direction);
}
} catch (IllegalArgumentException | IllegalAccessException | InvocationTargetException e) {
e.printStackTrace();
}
return flag;
}
private int compareNatural(Object leftVal, Object rightVal, Direction direction) {
int flag;
if (nullsFirst) {
flag = compareNulls(leftVal, rightVal, false, direction);
} else if (nullsLast) {
flag = compareNulls(rightVal, leftVal, true, direction);
} else {
flag = compare(leftVal.getClass(), leftVal, rightVal, direction);
}
return flag;
}
private int compareNulls(Object leftVal, Object rightVal, boolean reverse, Direction direction) {
return compareNulls(leftVal == null ? null : leftVal.getClass(), leftVal, rightVal, reverse, direction);
}
private int compareNulls(Class returnType, Object leftVal, Object rightVal, boolean reverse,
Direction direction) {
if (leftVal == rightVal) {
return 0;
} else if (leftVal == null) {
return RIGHT_IS_GREATER;
} else if (rightVal == null) {
return LEFT_IS_GREATER;
} else {
return reverse ? compare(returnType, rightVal, leftVal, direction) : compare(returnType, leftVal,
rightVal, direction);
}
}
private int compareZeros(BigDecimal leftNumber, BigDecimal rightNumber, boolean reverse, Direction direction) {
if (leftNumber.compareTo(rightNumber) == 0) {
return 0;
} else if (leftNumber.compareTo(BigDecimal.valueOf(0)) == 0) {
return RIGHT_IS_GREATER;
} else if (rightNumber.compareTo(BigDecimal.valueOf(0)) == 0) {
return LEFT_IS_GREATER;
} else {
return reverse ? compareNumber(rightNumber, leftNumber, direction) : compareNumber(leftNumber,
rightNumber, direction);
}
}
private int compareNumber(BigDecimal leftNumber, BigDecimal rightNumber, Direction direction) {
if (leftNumber.compareTo(rightNumber) == 0) {
return 0;
} else {
return direction == null || direction == Direction.ASC ? leftNumber.compareTo(rightNumber)
: rightNumber.compareTo(leftNumber);
}
}
private int compare(Class returnType, Object leftVal, Object rightVal, Direction direction) {
int flag;
if (Number.class.isAssignableFrom(returnType) || returnType == int.class || returnType == long.class
|| returnType == double.class || returnType == float.class) {
BigDecimal leftNumber = BigDecimal.valueOf(Double.valueOf(leftVal.toString()));
BigDecimal rightNumber = BigDecimal.valueOf(Double.valueOf(rightVal.toString()));
if (zerosFirst) {
flag = compareZeros(leftNumber, rightNumber, false, direction);
} else if (zerosLast) {
flag = compareZeros(rightNumber, leftNumber, true, direction);
} else {
flag = compareNumber(leftNumber, rightNumber, direction);
}
} else {
String methodReturn1 = leftVal.toString();
String methodReturn2 = rightVal.toString();
if (direction == null || direction == Direction.ASC) {
flag = methodReturn1.compareTo(methodReturn2);
} else {
flag = methodReturn2.compareTo(methodReturn1);
}
}
return flag;
}
};
}
这里排序规则比较多， 大概就是这样。
