代码中引用的其他类，请Java通用的排序工具类，支持数组、List、Map、Set排序，排序的内容可以是一个java定义的类型也可以是一个对象，根据对象的属性名称或方法名称进行排序（方法名称需要带括号），支持多个字段排序功能、如果对像中用一个map可以根据key排序对象。设置可以排序一个树型结构的对象。具体Demo和使用方法太多了。。将来有机会在补吧。代码中依赖的类参考地址如下：
以下是排序工具类的代码：
排序条件实体类，用于复杂的排序（比如排序一个user.getRole().name这样的对象）
package cn.elwy.common.util.sort;
import java.text.Format;
import java.text.ParsePosition;
import java.util.Comparator;
import java.util.Map;
/**
* 排序条件实体类
* @author huangsq
* @version 1.0, 2014-07-25
* @since 1.0, 2014-07-25
*/
public class SortCondition {
/** 是否升序 */
private boolean isAsc;
/** 方法名称 */
private String methodName;
/** 排序比较器 */
private Comparator<Object> comparator;
/** 格式化类 */
private Format format;
/** ParsePosition */
private ParsePosition parsePosition;
/** 排序的map */
private Map<?, ?> map;
/** 是否表格形式获取数据 */
private boolean isTable;
/** 排序的map按值排序 */
private boolean isSortMapByValue;
/** 如果元素为Map，是否支持方法名作为Key */
private boolean isSupportMap;
public SortCondition(boolean isAsc, String methodName) {
this(isAsc, methodName, null);
}
public SortCondition(boolean isAsc, String methodName, Comparator<Object> comparator) {
this.isAsc = isAsc;
this.methodName = methodName;
this.comparator = comparator;
}
public boolean isAsc() {
return isAsc;
}
public void setAsc(boolean isAsc) {
this.isAsc = isAsc;
}
public String getMethodName() {
return methodName;
}
public void setMethodName(String methodName) {
this.methodName = methodName;
}
public Comparator<Object> getComparator() {
return comparator;
}
public void setComparator(Comparator<Object> comparator) {
this.comparator = comparator;
}
public Format getFormat() {
return format;
}
public void setFormat(Format format) {
this.format = format;
}
public ParsePosition getParsePosition() {
return parsePosition;
}
public void setParsePosition(ParsePosition parsePosition) {
this.parsePosition = parsePosition;
}
public Map<?, ?> getMap() {
return map;
}
public void setMap(Map<?, ?> map) {
this.map = map;
}
public boolean isTable() {
return isTable;
}
public void setTable(boolean isTable) {
this.isTable = isTable;
}
public boolean isSortMapByValue() {
return isSortMapByValue;
}
public void setSortMapByValue(boolean isSortMapByValue) {
this.isSortMapByValue = isSortMapByValue;
}
public boolean isSupportMap() {
return isSupportMap;
}
public void setSupportMap(boolean isSupportMap) {
this.isSupportMap = isSupportMap;
}
}
排序工具类
package cn.elwy.common.util.sort;
import java.math.BigDecimal;
import java.text.Collator;
import java.text.Format;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import cn.elwy.common.util.AssertUtil;
import cn.elwy.common.util.ReflectUtil;
/**
* 利用反射机制进行排序工具类，支持数组、List、Set、Map的排序
* 可以支持多属性排序，支持子对象中的属性排序（例user对象中的role的name属性进行排序，method="getRole.getName"）
* @author huangsq
* @version 1.0, 2014-07-25
* @since 1.0, 2014-07-25
*/
public class SortUtil {
private static Logger logger = LoggerFactory.getLogger(SortUtil.class);
/** 中文排序 */
public static final Comparator<Object> CHINA_COMPARATOR = Collator.getInstance(Locale.CHINA);
private SortUtil() {
}
/**
* 根据指定的比较器排序一个数组中的元素
* @param arrays 需要排序的数组
* @param comparator 排序比较器
*/
public static void sort(Object[] arrays, Comparator<Object> comparator) {
Arrays.sort(arrays, comparator);
}
/**
* 根据指定的比较器排序一个List中的元素
* @param list 需要排序的集合
* @param comparator 排序比较器
*/
public static void sort(List<?> list, Comparator<Object> comparator) {
Collections.sort(list, comparator);
}
/**
* 根据指定的比较器排序一个Set中的元素
* @param set 需要排序的集合
* @param comparator 排序比较器
* @return Set TreeSet对象
*/
@SuppressWarnings("unchecked")
public static <T> Set<T> sort(Set<?> set, Comparator<Object> comparator) {
Set<Object> sortSet = new TreeSet<Object>(comparator);
sortSet.addAll(set);
return (Set<T>) sortSet;
}
/**
* 根据指定的比较器排序一个Map中的元素
* @param <K, V>
* @param map 需要排序的Map
* @param comparator 排序比较器
* @return Map TreeMap对象
*/
@SuppressWarnings("unchecked")
public static <K, V> Map<K, V> sort(Map<?, ?> map, Comparator<Object> comparator) {
Map<Object, Object> sortMap = new TreeMap<Object, Object>(comparator);
sortMap.putAll(map);
return (Map<K, V>) sortMap;
}
/**
* 排序一个数组中的元素，元素必需为Java提供的数据类型
* @param arrays 需要排序的数组
* @param isAsc 是否升序
*/
public static void sort(Object[] arrays, boolean isAsc) {
sort(arrays, getComparator(isAsc));
}
/**
* 排序一个List中的元素，元素必需为Java提供的数据类型
* @param list 需要排序的集合
* @param isAsc 是否升序
*/
public static void sort(List<?> list, boolean isAsc) {
sort(list, getComparator(isAsc));
}
/**
* 排序一个Set中的元素，元素必需为Java提供的数据类型
* @param set 需要排序的集合
* @param isAsc 是否升序
*/
public static <T> Set<T> sort(Set<?> set, boolean isAsc) {
return sort(set, getComparator(isAsc));
}
/**
* 根据Map的Key排序一个Map中的元素，Key必需为Java提供的数据类型
* @param <K, V>
* @param map 需要排序的map
* @param isAsc 是否升序
* @return
*/
public static <K, V> Map<K, V> sort(Map<?, ?> map, boolean isAsc) {
return sort(map, getComparator(isAsc));
}
/**
* 根据Map的Value排序一个Map中的元素，Value必需为Java提供的数据类型
* @param <K, V>
* @param map 需要排序的map
* @param isAsc 是否升序
* @return
*/
public static <K, V> Map<K, V> sortMapByValue(Map<?, ?> map, boolean isAsc) {
return sort(map, getComparator(map, isAsc));
}
/**
* 利用java反射机制排序一个对象数组
* @param arrays 需要排序的数组
* @param isAsc 是否升序
* @param fieldName 对象中的方法
*/
public static void sort(Object[] arrays, boolean isAsc, String fieldName) {
sort(arrays, getComparator(isAsc, fieldName));
}
/**
* 利用java反射机制排序一个集合对象
* @param list 需要排序的集合
* @param isAsc 是否升序
* @param fieldName 对象中的方法
*/
public static void sort(List<?> list, boolean isAsc, String fieldName) {
sort(list, getComparator(isAsc, fieldName));
}
/**
* 利用java反射机制排序一个Set对象
* @param set 需要排序的集合
* @param isAsc 是否升序
* @param fieldName 对象中的方法
*/
public static <T> Set<T> sort(Set<?> set, boolean isAsc, String fieldName) {
return sort(set, getComparator(isAsc, fieldName));
}
/**
* 利用java反射机制排序一个map对象，根据Map的Key排序一个Map中的元素
* @param <K, V>
* @param map 需要排序的map
* @param isAsc 是否升序
* @param fieldName key对象中的方法
* @return
*/
public static <K, V> Map<K, V> sort(Map<?, ?> map, boolean isAsc, String fieldName) {
return sort(map, getComparator(isAsc, fieldName));
}
/**
* 利用java反射机制排序一个map对象，根据Map的Value排序一个Map中的元素
* @param <T>
* @param map 需要排序的map
* @param isAsc 是否升序
* @param fieldName 对象中的方法
* @return
*/
public static <K, V> Map<K, V> sortMapByValue(Map<?, ?> map, boolean isAsc, String fieldName) {
return sort(map, getComparator(map, isAsc, fieldName));
}
/**
* 利用java反射机制排序一个对象数组
* @param arrays 需要排序的数组
* @param isAsc 是否升序，如果数组下标不足方法参数个数，将按最后一个状态表示后续方法的排序是否升序
* @param fieldNames 对象中的方法列表
*/
public static void sort(Object[] arrays, boolean[] isAsc, String... fieldNames) {
sort(arrays, getComparator(isAsc, fieldNames));
}
/**
* 利用java反射机制排序一个集合对象
* @param list 需要排序的集合
* @param isAsc 是否升序，如果数组下标不足方法参数个数，将按最后一个状态表示后续方法的排序是否升序
* @param fieldNames 对象中的方法列表
*/
public static void sort(List<?> list, boolean[] isAsc, String... fieldNames) {
sort(list, getComparator(isAsc, fieldNames));
}
/**
* 利用java反射机制排序一个Set对象
* @param set 需要排序的集合
* @param isAsc 是否升序，如果数组下标不足方法参数个数，将按最后一个状态表示后续方法的排序是否升序
* @param methodNameList 对象中的方法列表
*/
public static <T> Set<T> sort(Set<?> set, boolean[] isAsc, String... fieldNames) {
return sort(set, getComparator(isAsc, fieldNames));
}
/**
* 利用java反射机制排序一个map对象，根据Map的Key排序一个Map中的元素
* @param <K, V>
* @param map 需要排序的map
* @param isAsc 是否升序，如果数组下标不足方法参数个数，将按最后一个状态表示后续方法的排序是否升序
* @param fieldNames Key对象中的方法列表
* @return
*/
public static <K, V> Map<K, V> sort(Map<?, ?> map, boolean[] isAsc, String... fieldNames) {
return sort(map, getComparator(isAsc, fieldNames));
}
/**
* 利用java反射机制排序一个map对象，根据Map的Value排序一个Map中的元素
* @param <K, V>
* @param map 需要排序的map
* @param isAsc 是否升序，如果数组下标不足方法参数个数，将按最后一个状态表示后续方法的排序是否升序
* @param fieldNames 值对象中的方法列表
* @return
*/
public static <K, V> Map<K, V> sortMapByValue(Map<?, ?> map, boolean[] isAsc, String... fieldNames) {
return sort(map, getComparator(map, isAsc, fieldNames));
}
/**
* 根据指定的条件排序一个数组中的元素
* @param arrays 需要排序的数组
* @param condition 排序条件
*/
public static void sort(Object[] arrays, SortCondition condition) {
sort(arrays, getComparator(condition));
}
/**
* 根据指定的条件排序一个List中的元素
* @param list 需要排序的集合
* @param condition 排序条件
*/
public static void sort(List<?> list, SortCondition condition) {
sort(list, getComparator(condition));
}
/**
* 根据指定的条件排序一个Set中的元素
* @param set 需要排序的集合
* @param condition 排序条件
* @return Set TreeSet对象
*/
public static <T> Set<T> sort(Set<?> set, SortCondition condition) {
return sort(set, getComparator(condition));
}
/**
* 根据指定的比较器排序一个Map中的元素
* @param <K, V>
* @param map 需要排序的Map
* @param condition 排序条件
* @return Map TreeMap对象
*/
public static <K, V> Map<K, V> sort(Map<?, ?> map, SortCondition condition) {
return sort(map, getComparator(condition));
}
/**
* 根据指定的条件列表排序一个数组中的元素
* @param arrays 需要排序的数组
* @param conditionList 条件集，按list先后顺序进行排序
*/
public static void sort(Object[] arrays, List<SortCondition> conditionList) {
sort(arrays, getComparator(conditionList));
}
/**
* 根据指定的条件列表排序一个List中的元素
* @param list 需要排序的集合
* @param conditionList 条件集，按list先后顺序进行排序
*/
public static void sort(List<?> list, List<SortCondition> conditionList) {
sort(list, getComparator(conditionList));
}
/**
* 根据指定的条件列表排序一个Set中的元素
* @param set 需要排序的Set
* @param conditionList 条件集，按list先后顺序进行排序
* @return Set TreeSet对象
*/
public static <T> Set<T> sort(Set<?> set, List<SortCondition> conditionList) {
return sort(set, getComparator(conditionList));
}
/**
* 根据指定的条件列表排序一个Map中的元素
* @param <K, V>
* @param map 需要排序的Map
* @param conditionList 条件集，按list先后顺序进行排序
* @return Map TreeMap对象
*/
public static <K, V> Map<K, V> sort(Map<?, ?> map, List<SortCondition> conditionList) {
return sort(map, getComparator(conditionList));
}
/**
* 根据指定的比较器排序一个树形结构的数组对象中的元素
* @param arrays 需要排序的数组
* @param comparator 排序比较器
*/
public static void sortTree(Object[] arrays, Comparator<Object> comparator, String method) {
if (AssertUtil.isEmpty(arrays)) {
return;
}
sort(arrays, comparator);
for (Object object : arrays) {
Object[] child = ReflectUtil.getMethodValue(object, method);
if (AssertUtil.isNotEmpty(child)) {
sortTree(child, comparator, method);
}
}
}
/**
* 根据指定的比较器排序一个树形结构的List对象中的元素
* @param list 需要排序的集合
* @param comparator 排序比较器
*/
public static void sortTree(List<?> list, Comparator<Object> comparator, String method) {
if (AssertUtil.isEmpty(list)) {
return;
}
sort(list, comparator);
for (Object object : list) {
List<?> child = ReflectUtil.getMethodValue(object, method);
if (AssertUtil.isNotEmpty(child)) {
sortTree(child, comparator, method);
}
}
}
/**
* 根据排序方式获取Comparator
* @param isAsc 是否升序
* @return Comparator 排序比较器
*/
public static Comparator<Object> getComparator(final boolean isAsc) {
return new Comparator<Object>() {
public int compare(Object value1, Object value2) {
return compareTo(isAsc, value1, value2);
}
};
}
/**
* 根据Map的value排序方式获取Comparator
* @param isAsc 是否升序
* @return Comparator 排序比较器
*/
public static Comparator<Object> getComparator(final Map<?, ?> map, final boolean isAsc) {
return new Comparator<Object>() {
public int compare(Object o1, Object o2) {
return compareTo(isAsc, map.get(o1), map.get(o2));
}
};
}
/**
* 根据方法和排序方式获取Comparator，如果方法名称为空，则不使用反射机制
* @param isAsc 是否升序
* @param fieldName 方法名称
* @return Comparator 排序比较器
*/
public static Comparator<Object> getComparator(final boolean isAsc, final String fieldName) {
return new Comparator<Object>() {
public int compare(Object o1, Object o2) {
Object value1 = null;
Object value2 = null;
if (AssertUtil.isEmpty(fieldName)) {
value1 = o1;
value2 = o2;
} else {
// 利用反射得到具体的值
value1 = ReflectUtil.getFieldValue(o1, fieldName);
value2 = ReflectUtil.getFieldValue(o2, fieldName);
}
return compareTo(isAsc, value1, value2);
}
};
}
/**
* 根据方法名称列表和排序方式获取Comparator，方法名称列表不允许为空
* @param isAsc 是否升序
* @param methodNameList 方法名称列表，按list先后顺序进行排序
* @return Comparator 排序比较器
*/
public static Comparator<Object> getComparator(boolean[] isAsc, String... methodNames) {
List<Comparator<Object>> comparatorList = new ArrayList<Comparator<Object>>();
int index = isAsc.length - 1;
for (int i = 0; i < methodNames.length; i++) {
if (i >= index) {
comparatorList.add(getComparator(isAsc[index], methodNames[i]));
} else {
comparatorList.add(getComparator(isAsc[i], methodNames[i]));
}
}
return getComparatorByComparatorList(comparatorList);
}
/**
* 根据Map的value的方法和排序方式获取Comparator
* @param map 需要排序的map
* @param isAsc 是否升序
* @param fieldName Map值对象的方法
* @return Comparator 排序比较器
*/
public static Comparator<Object> getComparator(final Map<?, ?> map, final boolean isAsc, final String fieldName) {
return new Comparator<Object>() {
public int compare(Object o1, Object o2) {
Object value1 = null;
Object value2 = null;
if (AssertUtil.isEmpty(fieldName)) {
value1 = o1;
value2 = o2;
} else {
// 利用反射得到具体的值
value1 = ReflectUtil.getFieldValue(o1, fieldName);
value2 = ReflectUtil.getFieldValue(o2, fieldName);
}
return compareTo(isAsc, map.get(value1), map.get(value2));
}
};
}
/**
* 根据Map的value的方法名称列表和排序方式获取Comparator，方法名称列表不允许为空
* @param isAsc 是否升序
* @param methodNameList 值对象的方法名称列表，按list先后顺序进行排序
* @return Comparator 排序比较器
*/
public static Comparator<Object> getComparator(final Map<?, ?> map, final boolean[] isAsc, String... fieldNames) {
final List<Comparator<Object>> comparatorList = new ArrayList<Comparator<Object>>();
int index = isAsc.length - 1;
for (int i = 0; i < fieldNames.length; i++) {
if (i >= index) {
comparatorList.add(getComparator(map, isAsc[index], fieldNames[i]));
} else {
comparatorList.add(getComparator(map, isAsc[i], fieldNames[i]));
}
}
return getComparatorByComparatorList(comparatorList);
}
/**
* 根据排序条件获取Comparator，如果方法名称为空，则不使用反射机制
* @param condition 排序条件
* @return Comparator 排序比较器
*/
public static Comparator<Object> getComparator(final SortCondition condition) {
return new Comparator<Object>() {
public int compare(Object o1, Object o2) {
Object value1 = null;
Object value2 = null;
String methodName = condition.getMethodName();
Map<?, ?> map = condition.getMap();
if (map != null) { // 排序一个Map中的元素
if (condition.isSortMapByValue()) { // 根据value排序
value1 = map.get(o1);
value2 = map.get(o2);
} else { // 根据Key排序
value1 = o1;
value2 = o2;
}
} else if (AssertUtil.isEmpty(methodName)) { // 方法名称为空，直接比较两个对象
value1 = o1;
value2 = o2;
} else if (condition.isTable()) {
value1 = ReflectUtil.getTableColumnValue(o1, methodName, condition.isSupportMap());
value2 = ReflectUtil.getTableColumnValue(o2, methodName, condition.isSupportMap());
} else {
value1 = ReflectUtil.getTreeColumnValue(o1, methodName, condition.isSupportMap());
value1 = ReflectUtil.getTreeColumnValue(o2, methodName, condition.isSupportMap());
}
try {
Format format = condition.getFormat();
if (format != null) {
if (condition.getParsePosition() != null) {
value1 = format.parseObject(value1.toString(), condition.getParsePosition());
value2 = format.parseObject(value2.toString(), condition.getParsePosition());
} else {
value1 = format.parseObject(value1.toString());
value2 = format.parseObject(value2.toString());
}
}
if (condition.getComparator() != null) {
int result = condition.getComparator().compare(value1, value2);
if (!condition.isAsc()) {
result = -result;
}
return result;
} else {
return compareTo(condition.isAsc(), value1, value2);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
return 0;
}
}
};
}
/**
* 获取支持多个条件进行排序的比较器
* @param conditions 条件集，按list先后顺序进行排序
* @return Comparator 支持多个条件排序的比较器
*/
public static Comparator<Object> getComparator(List<SortCondition> conditions) {
final List<Comparator<Object>> comparatorList = new ArrayList<Comparator<Object>>();
for (SortCondition sortCondition : conditions) {
comparatorList.add(getComparator(sortCondition));
}
return getComparatorByComparatorList(comparatorList);
}
/**
* 获取支持多个条件进行排序的比较器
* @param comparatorList 排序比较器列表，按list先后顺序进行排序
* @return Comparator 支持多个条件排序的比较器
*/
public static Comparator<Object> getComparatorByComparatorList(final List<Comparator<Object>> comparatorList) {
return new Comparator<Object>() {
public int compare(Object o1, Object o2) {
for (Comparator<Object> c : comparatorList) {
int result = c.compare(o1, o2);
if (result != 0) {
return result;
}
}
return 0;
}
};
}
/**
* 比较两个对象的排列次序
* @param isAsc
* @param object1
* @param object2
* @return
*/
public static int compareTo(boolean isAsc, Object object1, Object object2) {
int result = 0;
try {
result = compareTo(object1, object2);
if (!isAsc) {
result = -result;
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return result;
}
/**
* 比较两个对象的排列次序
* @param object1
* @param object2
* @return
*/
public static int compareTo(Object object1, Object object2) {
boolean isEmptyV1 = AssertUtil.isEmpty(object1);
boolean isEmptyV2 = AssertUtil.isEmpty(object2);
if (!isEmptyV1 && !isEmptyV2) {
String value1 = object1.toString();
String value2 = object2.toString();
if (object1 instanceof Date) {
return ((Date) object1).compareTo((Date) object2);
} else if (object1 instanceof Number || (isNumeric(value1) && isNumeric(value2))) {
try {
return new BigDecimal(value1).compareTo(new BigDecimal(value2));
} catch (Exception e) {
return value1.compareTo(value2);
}
} else {
return value1.compareTo(value2);
}
} else if (!isEmptyV1 && isEmptyV2) {
return 1;
} else if (isEmptyV1 && !isEmptyV2) {
return -1;
} else {
return 0;
}
}
/**
* 判断字符串的内容是不是全是数字
* @param str
* @return
*/
public static boolean isNumeric(String str) {
if (str == null) {
return false;
}
int sz = str.length();
for (int i = 0; i < sz; i++) {
if (!Character.isDigit(str.charAt(i))) {
return false;
}
}
return true;
}
}
测试类，方法不全，后期有空补上
package cn.elwy.common.util;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import cn.elwy.common.Person;
import cn.elwy.common.util.sort.SortCondition;
import cn.elwy.common.util.sort.SortUtil;
/**
* 利用反射机制进行排序测试类
* @author huangsq
* @version 1.0, 2014-07-25
* @since 1.0, 2014-07-25
*/
public class SortUtilTest {
private List<Person> list;
private boolean isPrintResult = false;
@Before
public void initList() throws ParseException {
int n = 100;
list = new ArrayList<Person>();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (int i = 0; i < n; i++) {
int mod5 = i % 5;
boolean isStatus = mod5 == 1;
list.add(new Person(i, "张三", 19 + mod5, true, 20 - mod5, 1.5 * mod5, sdf.parse("1986-02-19"),
"2012-2-31 18:01:50"));
list.add(new Person(i, "张三2", 19 + mod5, true, 20 - mod5, 2.0 * mod5, sdf.parse("1986-02-19"),
"2012-2-31 18:01:50"));
list.add(new Person(i + mod5, "张三2", 19 + mod5, true, 20 - mod5, 2.0 * mod5, sdf.parse("1986-02-19"),
"2012-2-31 18:01:50"));
list.add(new Person(i, "张三2", 19 + mod5, true, 20 - mod5, 1.0 * mod5, sdf.parse("1986-02-19"),
"2012-1-31 18:01:50"));
list.add(new Person(i, "张三3", 26 + mod5, true, 30 - mod5, 3.0 * mod5, sdf.parse("1986-01-19"),
"2012-1-31 18:01:50"));
list.add(new Person(i, "张三2", 19 + mod5, true, 50 - mod5, 2.0 * mod5, sdf.parse("1986-03-19"),
"2012-1-31 18:01:50"));
list.add(new Person(i + 1, "李四", 19 + mod5, true, 6 - mod5, null, sdf.parse("1986-3-28"),
"2013-11-10 18:10:30"));
list.add(new Person(i + 2, "王五", 25 - mod5, isStatus, 3, 6.0 + mod5, sdf.parse("1986-01-31"),
"2012-1-31 20:01:50"));
list.add(new Person(i + 2, "王五2", 25 - mod5, isStatus, 3, 6.0 + mod5, sdf.parse("1986-05-19"),
"2012-5-31 20:01:50"));
list.add(new Person(i + 3, "赵六", 26 + mod5, !isStatus, 6 - mod5, 6.5 - mod5, sdf.parse("1986-02-19"),
"2012-2-31 20:11:50"));
}
}
@Test
public void testSortByByString() {
List<String> list1 = new ArrayList<String>();
list1.add("2231231");
list1.add("8");
list1.add("1123");
list1.add("g");
list1.add("9adfsad");
list1.add("9a2312dfsad");
list1.add("911adfsad");
list1.add("一");
list1.add("3");
list1.add("g");
list1.add("3");
list1.add("3");
list1.add("a");
System.out.println("testListByString=================");
long startTime = System.currentTimeMillis();
SortUtil.sort(list1, true);
System.out.println(System.currentTimeMillis() - startTime);
System.out.println("testListByString=================");
if (!isPrintResult) {
return;
}
for (int i = 0; i < list1.size(); i++) {
System.out.print(list1.get(i) + " ,");
}
}
@Test
public void testSortByMethod() throws ParseException {
// Integer id, String name, int age, boolean isStatus, long salary, Double salary1, Date birthday
System.out.println("testSortByMethod=====getRegTime============");
long startTime = System.currentTimeMillis();
SortUtil.sort(list, true, "regTime");
System.out.println(System.currentTimeMillis() - startTime);
print(list);
System.out.println("testSortByMethod======getRegTime===========");
}
@Test
public void testSortByMethods() throws ParseException {
// Integer id, String name, int age, boolean isStatus, long salary, Double salary1, Date birthday
System.out.println("testSortByMethods===getRegTime, getBirthday, getAge, getSalary1, getId==============");
long startTime = System.currentTimeMillis();
String[] methodNames = new String[] { "regTime", "birthday", "age", "salary1", "id" };
SortUtil.sort(list, new boolean[] { true }, methodNames);
System.out.println(System.currentTimeMillis() - startTime);
print(list);
System.out.println("testSortByMethods====getRegTime, getBirthday, getAge, getSalary1, getId=============");
}
@Test
public void testSortUtilByCondition() throws ParseException {
// Integer id, String name, int age, boolean isStatus, long salary, Double salary1, Date birthday
System.out.println("testSortUtilByCondition===========name======");
SortCondition condition = new SortCondition(false, "name");
condition.setSupportMap(true);
long startTime = System.currentTimeMillis();
SortUtil.sort(list, condition);
System.out.println(System.currentTimeMillis() - startTime);
print(list);
System.out.println("testSortUtilByCondition========name=========");
System.out.println("testSortUtilByCondition=====getRegTime============");
condition = new SortCondition(true, "getRegTime()");
condition.setFormat(new SimpleDateFormat("yyyy-MM-dd"));
startTime = System.currentTimeMillis();
SortUtil.sort(list, condition);
System.out.println(System.currentTimeMillis() - startTime);
print(list);
System.out.println("testSortUtilByCondition=========getRegTime========");
System.out.println("testSortUtilByCondition=======getAge==========");
condition = new SortCondition(false, "getAge()");
startTime = System.currentTimeMillis();
SortUtil.sort(list, condition);
System.out.println(System.currentTimeMillis() - startTime);
print(list);
System.out.println("testSortUtilByCondition==========getAge=======");
System.out.println("testSortUtilByCondition======birthday==========");
condition = new SortCondition(true, "birthday");
startTime = System.currentTimeMillis();
SortUtil.sort(list, condition);
System.out.println(System.currentTimeMillis() - startTime);
print(list);
System.out.println("testSortUtilByCondition============birthday=====");
System.out.println("testSortUtilByCondition=======salary1==========");
condition = new SortCondition(true, "salary1");
startTime = System.currentTimeMillis();
SortUtil.sort(list, condition);
System.out.println(System.currentTimeMillis() - startTime);
print(list);
System.out.println("testSortUtilByCondition========salary1=========");
System.out.println("testSortUtilByCondition==========id=======");
condition = new SortCondition(true, "id");
startTime = System.currentTimeMillis();
SortUtil.sort(list, condition);
System.out.println(System.currentTimeMillis() - startTime);
print(list);
System.out.println("testSortUtilByCondition==========id=======");
}
@Test
public void testSortUtilByConditions() throws ParseException {
// Integer id, String name, int age, boolean isStatus, long salary, Double salary1, Date birthday
System.out.println("testSortUtilByConditions====getRegTime(), getAge(), name, birthday, salary1, id===");
List<SortCondition> conditions = new ArrayList<SortCondition>();
SortCondition e1 = new SortCondition(true, "getRegTime()");
e1.setFormat(new SimpleDateFormat("yyyy-MM-dd"));
conditions.add(e1);
conditions.add(new SortCondition(false, "getAge()"));
SortCondition e = new SortCondition(false, "name");
e.setSupportMap(true);
conditions.add(e);
conditions.add(new SortCondition(true, "birthday"));
conditions.add(new SortCondition(true, "salary1"));
conditions.add(new SortCondition(true, "id"));
long startTime = System.currentTimeMillis();
SortUtil.sort(list, conditions);
System.out.println(System.currentTimeMillis() - startTime);
print(list);
System.out.println("testSortUtilByConditions====getRegTime(), getAge(), name, birthday, salary1, id===");
}
@Test
public void testSortByArray() throws ParseException {
Person[] arrays = list.toArray(new Person[] {});
// Integer id, String name, int age, boolean isStatus, long salary, Double salary1, Date birthday
System.out.println("testSortByArray======regTime, birthday, age, salary1, id===========");
long startTime = System.currentTimeMillis();
String[] methodNames = new String[] { "regTime", "birthday", "age", "salary1", "id" };
SortUtil.sort(arrays, new boolean[] { false, false, true }, methodNames);
System.out.println(System.currentTimeMillis() - startTime);
print(arrays);
System.out.println("testSortByArray======regTime, birthday, age, salary1, id===========");
}
private void print(List<Person> list) {
if (!isPrintResult) {
return;
}
for (Person person : list) {
System.out.println(person);
}
}
private void print(Person[] arrays) {
if (!isPrintResult) {
return;
}
for (Person person : arrays) {
System.out.println(person);
}
}
}
