对List排序,多重排序,通用各种对象的多重排序

package util;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 排序类，通用于获取的对象的方法值 都是int类型
 *
 * @author chenjy
 *
 */
public final class SortUtil {
    /**
     * 装载已经用过的规则 实现类似单例模式
     */
    private static Map<String, SortUtil> sortMap = new HashMap<String, SortUtil>();

    private Method[] methodArr = null;
    private int[] typeArr = null;

    /**
     * 构造函数 并保存该规则
     *
     * @param clazz
     * @param args
     */
    private <T> SortUtil(Class<T> clazz, String... args) {
        methodArr = new Method[args.length];
        typeArr = new int[args.length];
        for (int i = 0; i < args.length; i++) {
            String key = args[i].split("#")[0];
            try {
                methodArr[i] = clazz.getMethod(key, new Class[] {});
                typeArr[i] = Integer.valueOf(args[i].split("#")[1]);
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    }

    /**
     * 排序规则
     *
     * @author chenjy 2012-03-13
     */
    private Comparator<Object> comparator = new Comparator<Object>() {
        @Override
        public int compare(Object o1, Object o2) {
            for (int i = 0; i < methodArr.length; i++) {
                try {
                    Object value1 = methodArr[i].invoke(o1);
                    Object value2 = methodArr[i].invoke(o2);
                    double double1 = 0;
                    double double2 = 0;

                    if (value1 instanceof Integer) {
                        double1 = (Integer) value1;
                        double2 = (Integer) value2;
                    } else if (value1 instanceof Boolean) {
                        double1 = (Boolean) value1 ? 1 : -1;
                        double2 = (Boolean) value2 ? 1 : -1;
                    } else if (value1 instanceof Double) {
                        double1 = (Double) value1;
                        double2 = (Double) value2;
                    } else if (value1 instanceof Float) {
                        double1 = (Float) value1;
                        double2 = (Float) value2;
                    } else if (value1 instanceof Long) {
                        double1 = (Long) value1;
                        double2 = (Long) value2;
                    } else {
                        double1 = value1.toString().compareToIgnoreCase(
                                value2.toString());
                        double2 = -double1;
                    }
                    if (double1 == double2) {
                        continue;
                    }
                    if (typeArr[i] == 1) {
                        return (double1 > double2) ? 1 : -1;
                    } else {
                        return (double1 > double2) ? -1 : 1;
                    }
                } catch (Exception e1) {
                    e1.printStackTrace();
                }
            }
            return 0;
        }
    };

    /**
     * 获取排序规则 2012-3-13
     *
     * @return SortUtil
     * @author chenjy
     */
    private static <T> SortUtil getSort(Class<T> clazz, String... args) {
        String key = clazz.getName() + Arrays.toString(args);
        if (sortMap.containsKey(key)) {
            return sortMap.get(key);
        } else {
            SortUtil sort = new SortUtil(clazz, args);
            sortMap.put(key, sort);
            return sort;
        }
    }

    /**
     * <pre>
     * 首先会在容器中，根据class+规则去找。如果没有见则new
     * 调用方式 SortUtil.sort(list,"方法名#升序(1)/降序(-1)","..","..")
     * 后面字符串参数：比如："getMark#1","getAge#-1"
     * 表示先按照getMark的值按照升序排，如果相等再按照getAge的降序排
     * 如果返回值是true类型，若按照true先排："isOnline#1" ,若按照false先排："isOnline#-1"
     * </pre>
     *
     * @author chenjy 2012-3-13
     * @param list
     * @param args
     */
    public static <T> void sort(List<T> list, String... args) {
        if (list == null || list.size() == 0 || args.length == 0) {
            return;
        }
        SortUtil sort = getSort(list.get(0).getClass(), args);
        Collections.sort(list, sort.comparator);
    }

    /**
     * 给Map进行排序 对map的value进行排序
     *
     * @author chenjy 2012-3-13
     * @param map
     *            被排序的map
     * @param args
     *            排序方法条件：方法名x#1升序-1倒序, 方法名y#-1倒序
     * @return List<T>
     */
    public static <T, F> List<F> sortMap(Map<T, F> map, String... args) {
        List<F> list = new ArrayList<F>();
        if (map == null || map.isEmpty()) {
            return list;
        }
        list.addAll(map.values());
        sort(list, args);
        return list;
    }
}