一维数组转变为二维数组并进行排序

在现实情况中,我们会遇到这样的情况,从后台服务器拿到的数据是一个一维数组,但是我们显示的时候要分类显示(如:需要按照月份来分类显示列表),这个时候就需要把一维数组转换为二维数组,方便我们将数据显示出来。如果每一次都重新写转换的方法细节,那将浪费很多时间在重复的代码上面。

后面为了省时间,就花了半天时间,写出来下面的工具类,方便数据转换为所需的格式,同时进行数据排序。

下面先把代码放出来:

1.编写一个List,Set,Map转换的帮助类(CollectionUtils)

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

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

    /**
     * map转list,不排序
     *
     * @param map
     * @param 
     * @param 
     * @return
     */
    public static  List getListByMap(Map map) {
        return getListByMap(map, null);
    }

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

    /**
     * list转map,key为Integer,不排序
     *
     * @param list
     * @param 
     * @return
     */
    public static  Map getMapByList(List list) {
        return getMapByList(list, null);
    }

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

2.编写静态帮助类(AbsTwoDimensionalArrayUtils)

public abstract class AbsTwoDimensionalArrayUtils {
    //升序(从小到大)
    public static final int ASC_TYPE = 0;
    //降序(从大到小)
    public static final int DESC_TYPE = 1;

    protected Class kClass;

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

    /**
     * 获取排序后的二维数组
     *
     * @param dataArrays
     * @return
     */
    public List> getTwoDimensionalArrayByList(List dataArrays) {
        Map> mapByList = getMapByList(dataArrays);
        List> result = null;
        //排序小组的顺序
        Comparator>> keyComparator = getKeyListComparator();
        if (keyComparator != null) {
            result = new ArrayList<>();
            List>> list = new ArrayList>>(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> getMapByList(List dataArrays) {
        System.out.println("start time " + System.currentTimeMillis());
        HashMap> result = new HashMap>();
        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 value;
                if (result.containsKey(key)) {
                    //如果已经有了,就取出来
                    value = result.get(key);
                    value.add(v);
                } else {
                    value = new ArrayList<>();
                    value.add(v);
                }
                result.put(key, value);
            }
        }
        //排序每个组里面的数据
        Comparator valuecomparator = getValueListComparator();
        if (valuecomparator != null) {
            List mapListValue;
            for (Map.Entry> 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来实现分组
     *
     * @param v
     * @return
     */
    public abstract K getKey(V v);

    /**
     * 编写key的排序
     * @return
     */
    public abstract Comparator>> getKeyListComparator();

    /**
     * 编写value的排序规则
     * 
     * @return
     */
    public abstract Comparator getValueListComparator();
}

3.根据静态帮助类编写key为int和String的帮助类

A.key为Int时

public abstract class AbsIntTwoDimensionalArrayUtils extends AbsTwoDimensionalArrayUtils {
    protected Class 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>> getKeyListComparator() {
        return new Comparator>>() {
            @Override
            public int compare(Map.Entry> o1, Map.Entry> o2) {
                if (getMapKeySortType() == ASC_TYPE) {
                    return ascMapKey(o1, o2);
                } else {
                    return descMapkey(o1, o2);
                }
            }
        };
    }

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

    /**
     * 根据map的key升序排序
     *
     * @param o1
     * @param o2
     * @return
     */
    private Integer ascMapKey(Map.Entry> o1, Map.Entry> 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 getValueListComparator() {
        return new Comparator() {
            @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 extends AbsTwoDimensionalArrayUtils {
    protected Class 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>> getKeyListComparator() {
        return new Comparator>>() {
            @Override
            public int compare(Map.Entry> o1, Map.Entry> o2) {
                if (getMapKeySortType() == ASC_TYPE) {
                    return ascMapKey(o1, o2);
                } else {
                    return descMapkey(o1, o2);
                }
            }
        };
    }

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

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

    @Override
    public Comparator getValueListComparator() {
        return new Comparator() {
            @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.根据实际的数据类型,来定义帮助类,如果key是Int,就继承AbsIntTwoDimensionalArrayUtils;如果key是String,就继承AbsStringTwoDimensionalArrayUtils。

下面使用了int类型的例子:

public class TwoDimensionalArrayDemoUtils
        extends AbsIntTwoDimensionalArrayUtils {

    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.数据类型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();
    //获取二维数组
    List> lists = hashMapUtils.getTwoDimensionalArrayByList(users);
    //获取HashMap
    Map> mapByList = hashMapUtils.getMapByList(users);

这样操作下来,我们就可以将一个一维数组转换为一个二维数组或者一个Map结构的数据,同时将数据进行排序排序。

你可能感兴趣的:(一维数组转变为二维数组并进行排序)