一維數(shù)組轉變?yōu)槎S數(shù)組并進行排序

在現(xiàn)實情況中并蝗，我們會遇到這樣的情況，從后臺服務器拿到的數(shù)據(jù)是一個一維數(shù)組秸妥，但是我們顯示的時候要分類顯示（如：需要按照月份來分類顯示列表）滚停，這個時候就需要把一維數(shù)組轉換為二維數(shù)組，方便我們將數(shù)據(jù)顯示出來粥惧。如果每一次都重新寫轉換的方法細節(jié)键畴，那將浪費很多時間在重復的代碼上面。

后面為了省時間突雪，就花了半天時間起惕，寫出來下面的工具類，方便數(shù)據(jù)轉換為所需的格式咏删，同時進行數(shù)據(jù)排序惹想。

下面先把代碼放出來：

1.編寫一個List，Set督函，Map轉換的幫助類（CollectionUtils）

public class CollectionUtils {
    /**
     * List轉set
     *
     * @param list
     * @param <T>
     * @return
     */
    public static <T> Set<T> getSetByList(List<T> list) {
        Set<T> result = new HashSet<>(list);
        return result;
    }

    /**
     * set轉list
     *
     * @param setArrs
     * @param <T>
     * @return
     */
    public static <T> List<T> getListBySet(Set<T> setArrs) {
        ArrayList<T> result = new ArrayList<T>(setArrs);
        return result;
    }

    /**
     * map轉list嘀粱，不排序
     *
     * @param map
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K, V> List<V> getListByMap(Map<K, V> map) {
        return getListByMap(map, null);
    }

    /**
     * map轉list，排序
     *
     * @param map
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K, V> List<V> getListByMap(Map<K, V> map, Comparator<V> comparator) {
        ArrayList<V> result = new ArrayList<V>();
        for (V value : map.values()) {
            result.add(value);
        }
        if (comparator != null) {
            //進行排序
            Collections.sort(result, comparator);
        }
        return result;
    }

    /**
     * list轉map辰狡，key為Integer锋叨，不排序
     *
     * @param list
     * @param <V>
     * @return
     */
    public static <V> Map<Integer, V> getMapByList(List<V> list) {
        return getMapByList(list, null);
    }

    /**
     * list轉map，key為Integer宛篇，排序
     *
     * @param list
     * @param <V>
     * @return
     */
    public static <V> Map<Integer, V> getMapByList(List<V> list, Comparator<V> comparator) {
        if (comparator != null) {
            //進行排序
            Collections.sort(list, comparator);
        }
        if (list != null && list.size() > 0) {
            Map<Integer, V> result = new HashMap<>();
            for (int i = 0; i < list.size(); i++) {
                result.put(i, list.get(i));
            }
            return result;
        }
        return null;
    }
}

2.編寫靜態(tài)幫助類（AbsTwoDimensionalArrayUtils）

public abstract class AbsTwoDimensionalArrayUtils<K, V> {
    //升序（從小到大）
    public static final int ASC_TYPE = 0;
    //降序（從大到型藁恰）
    public static final int DESC_TYPE = 1;

    protected Class<K> kClass;

    public AbsTwoDimensionalArrayUtils(Class<K> kClass) {
        this.kClass = kClass;
    }

    /**
     * 獲取排序后的二維數(shù)組
     *
     * @param dataArrays
     * @return
     */
    public List<List<V>> getTwoDimensionalArrayByList(List<V> dataArrays) {
        Map<K, List<V>> mapByList = getMapByList(dataArrays);
        List<List<V>> result = null;
        //排序小組的順序
        Comparator<Map.Entry<K, List<V>>> keyComparator = getKeyListComparator();
        if (keyComparator != null) {
            result = new ArrayList<>();
            List<Map.Entry<K, List<V>>> list = new ArrayList<Map.Entry<K, List<V>>>(mapByList.entrySet());
            Collections.sort(list, keyComparator);
            for (int i = 0; i < list.size(); i++) {
                result.add(list.get(i).getValue());
            }
            System.out.println("end time " + System.currentTimeMillis());
        } else {
            //直接轉換
            result = CollectionUtils.getListByMap(mapByList);
        }
        return result;
    }

    /**
     * 獲取HashMap
     *
     * @param dataArrays
     * @return
     */
    public Map<K, List<V>> getMapByList(List<V> dataArrays) {
        System.out.println("start time " + System.currentTimeMillis());
        HashMap<K, List<V>> result = new HashMap<K, List<V>>();
        if (dataArrays != null && dataArrays.size() > 0) {
            K key;
            for (int i = 0; i < dataArrays.size(); i++) {
                V v = dataArrays.get(i);
                key = getKey(v);
                List<V> value;
                if (result.containsKey(key)) {
                    //如果已經(jīng)有了，就取出來
                    value = result.get(key);
                    value.add(v);
                } else {
                    value = new ArrayList<>();
                    value.add(v);
                }
                result.put(key, value);
            }
        }
        //排序每個組里面的數(shù)據(jù)
        Comparator<V> valuecomparator = getValueListComparator();
        if (valuecomparator != null) {
            List<V> mapListValue;
            for (Map.Entry<K, List<V>> entry : result.entrySet()) {
                mapListValue = entry.getValue();
                if (mapListValue != null && mapListValue.size() > 0) {
                    Collections.sort(mapListValue, valuecomparator);
                }
            }
        }
        System.out.println("end time " + System.currentTimeMillis());
        return result;
    }


    /**
     * 通過V來實現(xiàn)分組
     *
     * @param v
     * @return
     */
    public abstract K getKey(V v);

    /**
     * 編寫key的排序
     * @return
     */
    public abstract Comparator<Map.Entry<K, List<V>>> getKeyListComparator();

    /**
     * 編寫value的排序規(guī)則
     * 
     * @return
     */
    public abstract Comparator<V> getValueListComparator();
}

3.根據(jù)靜態(tài)幫助類編寫key為int和String的幫助類

A.key為Int時

public abstract class AbsIntTwoDimensionalArrayUtils<V> extends AbsTwoDimensionalArrayUtils<Integer, V> {
    protected Class<V> vClass;
    protected Field field;
    protected Method method;

    protected Field sortField;
    protected Method sortMethod;

    public AbsIntTwoDimensionalArrayUtils(Class vClass) {
        super(Integer.class);
        this.vClass = vClass;

        String mapName = getMapKeyName();
        String sortName = getSortName();
        //獲取分類字段
        try {
            field = vClass.getField(mapName);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        //獲取排序字段
        try {
            sortField = vClass.getField(sortName);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        //獲取分類的字段的值的method
        try {
            String firstLetter = mapName.substring(0, 1).toUpperCase();
            String getter = "get" + firstLetter + mapName.substring(1);
            method = vClass.getMethod(getter, new Class[]{});
        } catch (Exception e) {
            e.printStackTrace();
        }
        //獲取排序的字段的值的method
        try {
            String firstLetterSort = sortName.substring(0, 1).toUpperCase();
            String getter = "get" + firstLetterSort + sortName.substring(1);
            sortMethod = vClass.getMethod(getter, new Class[]{});
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public Integer getKey(V v) {
        if (field == null) {
            //說明是字段不為public叫倍，去尋找get方法
            try {
                return (Integer) method.invoke(v, new Integer[]{});
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        } else {
            try {
                return field.getInt(v);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return 0;
    }

    @Override
    public Comparator<Map.Entry<Integer, List<V>>> getKeyListComparator() {
        return new Comparator<Map.Entry<Integer, List<V>>>() {
            @Override
            public int compare(Map.Entry<Integer, List<V>> o1, Map.Entry<Integer, List<V>> o2) {
                if (getMapKeySortType() == ASC_TYPE) {
                    return ascMapKey(o1, o2);
                } else {
                    return descMapkey(o1, o2);
                }
            }
        };
    }

    /**
     * 根據(jù)map的key降序排序
     *
     * @param o1
     * @param o2
     * @return
     */
    private Integer descMapkey(Map.Entry<Integer, List<V>> o1, Map.Entry<Integer, List<V>> o2) {
        try {
            if (o1.getKey() > o2.getKey()) {
                return -1;
            }
            if (o1.getKey() < o2.getKey()) {
                return 1;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    /**
     * 根據(jù)map的key升序排序
     *
     * @param o1
     * @param o2
     * @return
     */
    private Integer ascMapKey(Map.Entry<Integer, List<V>> o1, Map.Entry<Integer, List<V>> o2) {
        try {
            if (o1.getKey() < o2.getKey()) {
                return -1;
            }
            if (o1.getKey() > o2.getKey()) {
                return 1;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    @Override
    public Comparator<V> getValueListComparator() {
        return new Comparator<V>() {
            @Override
            public int compare(V o1, V o2) {
                if (getSortType() == ASC_TYPE) {
                    return sortAsc(o1, o2);
                } else {
                    return sortDesc(o1, o2);
                }
            }
        };
    }

    /**
     * 降序排序每個子對象
     *
     * @param o1
     * @param o2
     * @return
     */
    private int sortDesc(V o1, V o2) {
        if (sortField == null) {
            try {
                if (isIntSortFiled()) {
                    return ((Integer) sortMethod.invoke(o2, new Integer[]{})).compareTo((Integer) sortMethod.invoke(o1, new Integer[]{}));
                } else {
                    return ((String) sortMethod.invoke(o2, new String[]{})).compareTo((String) sortMethod.invoke(o1, new String[]{}));
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        } else {
            try {
                if (isIntSortFiled()) {
                    if (sortField.getInt(o1) > sortField.getInt(o2)) {
                        return -1;
                    }
                    if (sortField.getInt(o1) < sortField.getInt(o2)) {
                        return 1;
                    }
                } else {
                    return ((String) sortField.get(o2)).compareTo((String) sortField.get(o1));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return 0;
    }

    /**
     * 升序排序每個子對象
     *
     * @param o1
     * @param o2
     * @return
     */
    private int sortAsc(V o1, V o2) {
        if (sortField == null) {
            try {
                if (isIntSortFiled()) {
                    return ((Integer) sortMethod.invoke(o1, new Integer[]{})).compareTo((Integer) sortMethod.invoke(o2, new Integer[]{}));
                } else {
                    return ((String) sortMethod.invoke(o1, new String[]{})).compareTo((String) sortMethod.invoke(o2, new String[]{}));
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        } else {
            try {
                if (isIntSortFiled()) {
                    if (sortField.getInt(o1) > sortField.getInt(o2)) {
                        return 1;
                    }
                    if (sortField.getInt(o1) < sortField.getInt(o2)) {
                        return -1;
                    }
                } else {
                    return ((String) sortField.get(o1)).compareTo((String) sortField.get(o2));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return 0;
    }

    /**
     * 獲取對象的排序字段名
     *
     * @return
     */
    public abstract String getSortName();

    /**
     * 獲取map的key字段名
     *
     * @return
     */
    public abstract String getMapKeyName();

    /**
     * 獲取每個對象的排序方式（升序/降序）
     *
     * @return
     */
    public abstract int getSortType();

    /**
     * 獲取map的key的排序方式（升序/降序）
     *
     * @return
     */
    public abstract int getMapKeySortType();

    /**
     * 對象的字段是否是int類型的排序字段
     *
     * @return
     */
    public abstract boolean isIntSortFiled();
}

B.key為String時

public abstract class AbsStringTwoDimensionalArrayUtils<V> extends AbsTwoDimensionalArrayUtils<String, V> {
    protected Class<V> vClass;
    protected Field field;
    protected Method method;

    protected Field sortField;
    protected Method sortMethod;

    public AbsStringTwoDimensionalArrayUtils(Class vClass) {
        super(String.class);
        this.vClass = vClass;

        String mapName = getMapKeyName();
        String sortName = getSortName();
        //獲取分類字段
        try {
            field = vClass.getField(mapName);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        //獲取排序字段
        try {
            sortField = vClass.getField(sortName);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        //獲取分類的字段的值的method
        try {
            String firstLetter = mapName.substring(0, 1).toUpperCase();
            String getter = "get" + firstLetter + mapName.substring(1);
            method = vClass.getMethod(getter, new Class[]{});
        } catch (Exception e) {
            e.printStackTrace();
        }
        //獲取排序的字段的值的method
        try {
            String firstLetterSort = sortName.substring(0, 1).toUpperCase();
            String getter = "get" + firstLetterSort + sortName.substring(1);
            sortMethod = vClass.getMethod(getter, new Class[]{});
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public String getKey(V v) {
        if (field == null) {
            //說明是字段不為public偷卧，去尋找get方法
            try {
                return (String) method.invoke(v, new String[]{});
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        } else {
            try {
                return (String) field.get(v);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return "";
    }

    @Override
    public Comparator<Map.Entry<String, List<V>>> getKeyListComparator() {
        return new Comparator<Map.Entry<String, List<V>>>() {
            @Override
            public int compare(Map.Entry<String, List<V>> o1, Map.Entry<String, List<V>> o2) {
                if (getMapKeySortType() == ASC_TYPE) {
                    return ascMapKey(o1, o2);
                } else {
                    return descMapkey(o1, o2);
                }
            }
        };
    }

    /**
     * 根據(jù)map的key降序排序
     *
     * @param o1
     * @param o2
     * @return
     */
    private Integer descMapkey(Map.Entry<String, List<V>> o1, Map.Entry<String, List<V>> o2) {
        try {
            return o2.getKey().compareTo(o1.getKey());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    /**
     * 根據(jù)map的key升序排序
     *
     * @param o1
     * @param o2
     * @return
     */
    private Integer ascMapKey(Map.Entry<String, List<V>> o1, Map.Entry<String, List<V>> o2) {
        try {
            return o1.getKey().compareTo(o2.getKey());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    @Override
    public Comparator<V> getValueListComparator() {
        return new Comparator<V>() {
            @Override
            public int compare(V o1, V o2) {
                if (getSortType() == ASC_TYPE) {
                    return sortAsc(o1, o2);
                } else {
                    return sortDesc(o1, o2);
                }
            }
        };
    }

    /**
     * 降序排序每個子對象
     *
     * @param o1
     * @param o2
     * @return
     */
    private int sortDesc(V o1, V o2) {
        if (sortField == null) {
            try {
                if (isIntSortFiled()) {
                    return ((Integer) sortMethod.invoke(o2, new Integer[]{})).compareTo((Integer) sortMethod.invoke(o1, new Integer[]{}));
                } else {
                    return ((String) sortMethod.invoke(o2, new String[]{})).compareTo((String) sortMethod.invoke(o1, new String[]{}));
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        } else {
            try {
                if (isIntSortFiled()) {
                    if (sortField.getInt(o1) > sortField.getInt(o2)) {
                        return -1;
                    }
                    if (sortField.getInt(o1) < sortField.getInt(o2)) {
                        return 1;
                    }
                } else {
                    return ((String) sortField.get(o2)).compareTo((String) sortField.get(o1));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return 0;
    }

    /**
     * 升序排序每個子對象
     *
     * @param o1
     * @param o2
     * @return
     */
    private int sortAsc(V o1, V o2) {
        if (sortField == null) {
            try {
                if (isIntSortFiled()) {
                    return ((Integer) sortMethod.invoke(o1, new Integer[]{})).compareTo((Integer) sortMethod.invoke(o2, new Integer[]{}));
                } else {
                    return ((String) sortMethod.invoke(o1, new String[]{})).compareTo((String) sortMethod.invoke(o2, new String[]{}));
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        } else {
            try {
                if (isIntSortFiled()) {
                    if (sortField.getInt(o1) > sortField.getInt(o2)) {
                        return 1;
                    }
                    if (sortField.getInt(o1) < sortField.getInt(o2)) {
                        return -1;
                    }
                } else {
                    return ((String) sortField.get(o1)).compareTo((String) sortField.get(o2));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return 0;
    }

    /**
     * 獲取對象的排序字段名
     *
     * @return
     */
    public abstract String getSortName();

    /**
     * 獲取map的key字段名
     *
     * @return
     */
    public abstract String getMapKeyName();

    /**
     * 獲取每個對象的排序方式（升序/降序）
     *
     * @return
     */
    public abstract int getSortType();

    /**
     * 獲取map的key的排序方式（升序/降序）
     *
     * @return
     */
    public abstract int getMapKeySortType();

    /**
     * 對象的字段是否是int類型的排序字段
     *
     * @return
     */
    public abstract boolean isIntSortFiled();
}

----------------------------------------華麗的分割線----------------------------------------------------------

下面就到了萬眾期待的使用方式了：

1.根據(jù)實際的數(shù)據(jù)類型嘿般，來定義幫助類，如果key是Int涯冠，就繼承AbsIntTwoDimensionalArrayUtils；如果key是String逼庞，就繼承AbsStringTwoDimensionalArrayUtils蛇更。

下面使用了int類型的例子：

public class TwoDimensionalArrayDemoUtils
        extends AbsIntTwoDimensionalArrayUtils<User> {

    public TwoDimensionalArrayDemoUtils() {
        super(User.class);
    }

    @Override
    public String getSortName() {
        return "name";
    }
    
    @Override
    public int getSortType() {
        return ASC_TYPE;
    }

    @Override
    public int getMapKeySortType() {
        return ASC_TYPE;
    }

    @Override
    public String getMapKeyName() {
        return "age";
    }

    @Override
    public boolean isIntSortFiled() {
        return false;
    }
}

2.數(shù)據(jù)類型User類如下：

public class User {
    public int id;
    private int age;
    public String name = "";

    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

3.調用方式

    TwoDimensionalIntArrayDemoUtils hashMapUtils = new TwoDimensionalIntArrayDemoUtils();
    //獲取二維數(shù)組
    List<List<User>> lists = hashMapUtils.getTwoDimensionalArrayByList(users);
    //獲取HashMap
    Map<Integer, List<User>> mapByList = hashMapUtils.getMapByList(users);

這樣操作下來，我們就可以將一個一維數(shù)組轉換為一個二維數(shù)組或者一個Map結構的數(shù)據(jù)赛糟，同時將數(shù)據(jù)進行排序排序派任。