java8 排序 orderBy

OrderByUtils:(待优化)

package com.icil.report.utils;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* *************************************************************************
* <PRE>
* @param <E>
*
@ClassName:
: ListUtil
*
*
@Description:
:
*
*
@Creation Date
: 13 May 2019 2:48:52 PM
*
*
@Author
:
Sea
*
*
* </PRE>
**************************************************************************
*/
@SuppressWarnings("all")
public class OrderByUtils{
private static Logger
LOGGER=LoggerFactory.getLogger(OrderByUtils.class);
//#######################################################################################################
//
order by
java 7 && java8
// ######################################################################################################
/**
* @Desc: java8 parallelStream
* @param colls :需要排序的集合（pojo）
* @param firstfiledName
:先按排序的字段
* @param secondfiledName
：:再按排序的字段
* @return
*/
//
public static <E> List<E>
orderby(Collection<E> colls,String firstfiledName,String secondfiledName){
//
return colls.parallelStream().sorted(Comparator.comparing(d->getFieldStringValueByName(d,firstfiledName)).thenComparing(d->getFieldStringValueByName(d,secondfiledName))).collect(Collectors.toList());
//
}
/**
*
@Desc: java8 parallelStream
* @param colls
* @param filedName 排序的字段
* @param fieldType
排序的字段的类型
* @return
*/
public static <E> List<E>
orderbyPro(Collection<E> colls,String filedName,Class fieldType){
switch (fieldType.getName()) {
case "java.lang.Integer":
return colls.parallelStream().sorted(Comparator.comparing(d->(Integer)getFieldValueByName(d,filedName))).collect(Collectors.toList());
case "java.lang.Long":
return colls.parallelStream().sorted(Comparator.comparing(d->(Long)getFieldValueByName(d,filedName))).collect(Collectors.toList());
case "java.lang.Double":
return colls.parallelStream().sorted(Comparator.comparing(d->(Double)getFieldValueByName(d,filedName))).collect(Collectors.toList());
case "java.util.Date":
return colls.parallelStream().sorted(Comparator.comparing(d->(Date)getFieldValueByName(d,filedName))).collect(Collectors.toList());
case "java.lang.Float":
return colls.parallelStream().sorted(Comparator.comparing(d->(Float)getFieldValueByName(d,filedName))).collect(Collectors.toList());
case "java.lang.String":
return colls.parallelStream().sorted(Comparator.comparing(d->(String)getFieldStringValueByName(d,filedName))).collect(Collectors.toList());
default:
return null;
}
}
/**
*
* @param colls
* @param filedName
:pojo 的属性名
如 user -->name
* @return
*/
public static <E> List<E>
orderby(List<E> colls, String filedName,Class fieldType){
getMyComparator(colls,filedName,fieldType);
colls.sort(getMyComparator(colls,filedName,fieldType));
return colls;
}
/**
* 通过属性名称对集合分组
* @Desc:java 8 stream api, list 会过滤掉group by filed 的非空字段
* @param colls
集合必须为对象 eg: List<Employee>
* @param fieldName为集合中对象的属性名称
eg: Employee-->name
* @return
* extends Comparable<T>
*/
public static final <D> Map<Object ,List<D>> groupByPro(Collection<D> colls ,String fieldName){
//filter
//
List<D> filterlist = colls.parallelStream().filter(r->getFieldValueByName(r,fieldName)!=null).collect(Collectors.toList());
for (D d : colls) {
if(OrderByUtils.getFieldValueByName(d, fieldName)==null){
OrderByUtils.setFieldValueByName(d, fieldName, "null");
}
}
//group by 
Map<Object, List<D>> collect = colls.stream().collect(Collectors.groupingBy(r->getFieldValueByName(r,fieldName)));
return collect;
}
/**
* 根据属性名称获取属性值
* */
public static Object getFieldValueByName(Object pojo,String fieldName) {
try {
String firstLetter = fieldName.substring(0, 1).toUpperCase();
String getter = "get" + firstLetter + fieldName.substring(1);
Method method = pojo.getClass().getMethod(getter, new Class[] {});
Object value = method.invoke(pojo, new Object[] {});
return value;
} catch (Exception e) {
LOGGER.error(e.getMessage(),e);
return null;
}
}
/**
*
* @param pojo
* @param fieldName
* @param value just can be
Integer(int)
Double(double)
Long(ong)
Date
String
*/
public static void setFieldValueByName(Object pojo,String fieldName,Object value) {
try {
String firstLetter = fieldName.substring(0, 1).toUpperCase();
String seter = "set" + firstLetter + fieldName.substring(1);
value = Optional.ofNullable(value).orElseGet(()-> new String("null"));
String simpleName = value.getClass().getSimpleName();
Class
class1;
switch (simpleName) {
case "Integer":
class1=Integer.class;
break;
case "Double":
class1=Double.class;
break;
case "Long":
class1=Long.class;
break;
case "Date":
class1=Date.class;
break;
default:
class1=String.class;
break;
}
Method setmethod = pojo.getClass().getMethod(seter, class1);
setmethod.invoke(pojo,value);
} catch (Exception e) {
LOGGER.error(e.getMessage(),e);
}
}
/**
* 根据属性名称获取属性值 (获取String型)
* */
public static String getFieldStringValueByName(Object o,String fieldName) {
try {
String firstLetter = fieldName.substring(0, 1).toUpperCase();
String getter = "get" + firstLetter + fieldName.substring(1);
Method method = o.getClass().getMethod(getter, new Class[] {});
String value = (String) method.invoke(o, new Object[] {});
return value;
} catch (Exception e) {
LOGGER.error(e.getMessage(),e);
return null;
}
}
public static
<E> Comparator<E>
getMyComparator(List<E> colls, String filedName,Class fieldType){
Comparator<E> comparator = new Comparator<E>() {
@Override
public int compare(E o1, E o2) {
int result=0;
switch (fieldType.getName()) {
case "java.lang.Integer":
result=
getFieldValueByNameAndType(o1,filedName,Integer.class).compareTo(getFieldValueByNameAndType(o2,filedName,Integer.class));
break;
case "java.lang.Long":
result= getFieldValueByNameAndType(o1,filedName,Long.class).compareTo(getFieldValueByNameAndType(o2,filedName,Long.class));
break;
case "java.lang.Double":
result= getFieldValueByNameAndType(o1,filedName,Double.class).compareTo(getFieldValueByNameAndType(o2,filedName,Double.class));
break;
case "java.util.Date":
result= getFieldValueByNameAndType(o1,filedName,Date.class).compareTo(getFieldValueByNameAndType(o2,filedName,Date.class));
break;
case "java.lang.Float":
result= getFieldValueByNameAndType(o1,filedName,Float.class).compareTo(getFieldValueByNameAndType(o2,filedName,Float.class));
break;
case "java.lang.String":
result= getFieldValueByNameAndType(o1,filedName,String.class).compareTo(getFieldValueByNameAndType(o2,filedName,String.class));
break;
default:
result= 0;
break;
}
return
result;
}
};
return comparator;
}
/**
* @param pojo
* @param fieldName
* @param fieldType
* @return
*/
public static <T> T getFieldValueByNameAndType(Object pojo,String fieldName,Class<T> fieldType) {
try {
String firstLetter = fieldName.substring(0, 1).toUpperCase();
String getter = "get" + firstLetter + fieldName.substring(1);
Method method = pojo.getClass().getMethod(getter, new Class[] {});
T value = (T) method.invoke(pojo, new Object[] {});
return value;
} catch (Exception e) {
LOGGER.error(e.getMessage(),e);
return null;
}
}
/**
* @param <T>
* @param pojo
* @param fieldName
* @param fieldType
* @return
*/
public static <T> T
getFieldValueByNameAndType(Object pojo,String fieldName) {
try {
String firstLetter = fieldName.substring(0, 1).toUpperCase();
String getter = "get" + firstLetter + fieldName.substring(1);
Field field = pojo.getClass().getDeclaredField(fieldName); // 获取属性
Class<?> type = field.getType();
Method method = pojo.getClass().getMethod(getter, type);
T value = (T) method.invoke(pojo, new Object[] {});
return value;
} catch (Exception e) {
LOGGER.error(e.getMessage(),e);
return null;
}
}
}

 

 

 

更多可以参考：http://www.importnew.com/15259.html

Test ：

package com.icil.report.jdbc;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
import org.junit.Test;
import com.icil.report.pojo.GroupByCourier;
public class OrderByTest {
/**
* java7 普通排序
* 多条件组合排序: //先根据NumberOfShipments 排序，然后在更具 Courier 排序
* 从JDK 8开始，我们现在可以把多个Comparator链在一起（chain together）去建造更复杂的比较逻辑：
* @throws Exception
*/
@Test
public void orderBYtest1() throws Exception {
ArrayList<GroupByCourier> arrayList = new ArrayList<GroupByCourier>();
//
GroupByCourier(String courier, Integer numberOfShipments, Integer numberOfSubscriptions)
arrayList.add(new GroupByCourier("f",2,3));
arrayList.add(new GroupByCourier("b",10,6));
arrayList.add(new GroupByCourier("a",4,1));
arrayList.add(new GroupByCourier("c",15,8));
arrayList.add(new GroupByCourier("c",1,8));
arrayList.add(new GroupByCourier("c",1,8));
arrayList.add(new GroupByCourier("c",19,8));
arrayList.add(new GroupByCourier("c",1,8));
arrayList.add(new GroupByCourier("c",1,8));
arrayList.sort(Comparator.comparing(GroupByCourier::getNumberOfShipments).thenComparing(GroupByCourier::getCourier));
//先根据NumberOfShipments 排序，然后在更具 Courier 排序

Comparator.comparing(GroupByCourier::getNumberOfShipments).thenComparing(GroupByCourier::getCourier);
arrayList.forEach(r->{System.out.println(r.getCourier() +" -- "+r.getNumberOfShipments()+"--"+r.getNumberOfSubscriptions());});
}
/**
*
java7 并行流式排序
* 多条件组合排序: //先根据NumberOfShipments 排序，然后在更具 Courier 排序 ,然后在根据 NumberOfSubscriptions 排序
* 从JDK 8开始，我们现在可以把多个Comparator链在一起（chain together）去建造更复杂的比较逻辑：
* @throws Exception
*/
@Test
public void orderBYtest02() throws Exception {
ArrayList<GroupByCourier> arrayList = new ArrayList<GroupByCourier>();
//
GroupByCourier(String courier, Integer numberOfShipments, Integer numberOfSubscriptions)
arrayList.add(new GroupByCourier("f",2,3));
arrayList.add(new GroupByCourier("b",10,6));
arrayList.add(new GroupByCourier("a",4,1));
arrayList.add(new GroupByCourier("c",15,8));
arrayList.add(new GroupByCourier("c",1,8));
arrayList.add(new GroupByCourier("c",1,8));
arrayList.add(new GroupByCourier("c",19,8));
arrayList.add(new GroupByCourier("c",1,8));
arrayList.add(new GroupByCourier("c",1,8));
//先根据NumberOfShipments 排序，然后在更具 Courier 排序 ,然后在根据 NumberOfSubscriptions 排序
//List<GroupByCourier> collect = arrayList.parallelStream().sorted(Comparator.comparing(GroupByCourier::getNumberOfShipments).thenComparing(GroupByCourier::getCourier)).collect(Collectors.toList());
List<GroupByCourier> collect = arrayList.parallelStream().sorted(Comparator.comparing(GroupByCourier::getNumberOfShipments).thenComparing(GroupByCourier::getCourier).thenComparing(GroupByCourier::getNumberOfSubscriptions)).collect(Collectors.toList());
System.err.println(collect);
collect.forEach(r->{System.out.println(r.getCourier() +" -- "+r.getNumberOfShipments()+"--"+r.getNumberOfSubscriptions());});
}
/**
*
java8 并行流式排序
反转排序
*  JDK 8同样提供了一个有用的方法用来反转Comparator（reverse Comparator）——我们可以快速地利用它来反转我们的排序
* 多条件组合排序: //先根据NumberOfShipments 排序，然后在更具 Courier 排序 ,然后在根据 NumberOfSubscriptions 排序
* 从JDK 8开始，我们现在可以把多个Comparator链在一起（chain together）去建造更复杂的比较逻辑：
* @throws Exception
*/
@Test
public void orderBYtest04() throws Exception {
ArrayList<GroupByCourier> arrayList = new ArrayList<GroupByCourier>();
//
GroupByCourier(String courier, Integer numberOfShipments, Integer numberOfSubscriptions)
arrayList.add(new GroupByCourier("f",2,3));
arrayList.add(new GroupByCourier("b",10,6));
arrayList.add(new GroupByCourier("a",4,1));
arrayList.add(new GroupByCourier("c",15,8));
arrayList.add(new GroupByCourier("c",1,8));
arrayList.add(new GroupByCourier("c",1,8));
arrayList.add(new GroupByCourier("c",19,8));
arrayList.add(new GroupByCourier("c",1,8));
arrayList.add(new GroupByCourier("c",1,8));
//先根据NumberOfShipments 排序，然后在更具 Courier 排序 ,然后在根据 NumberOfSubscriptions 排序 (现在是反过来)
Comparator<GroupByCourier>
compars = Comparator.comparing(GroupByCourier::getNumberOfShipments).thenComparing(GroupByCourier::getCourier).thenComparing(GroupByCourier::getNumberOfSubscriptions);
List<GroupByCourier> collect = arrayList.parallelStream().sorted(compars.reversed()).collect(Collectors.toList());
System.err.println(collect);
collect.forEach(r->{System.out.println(r.getCourier() +" -- "+r.getNumberOfShipments()+"--"+r.getNumberOfSubscriptions());});
}
}