【代码分享】关于List<V>按V的某个属性分组的通用代码实现

        背景是这样的：我们的项目中，定义了各种各样的和表对应的实体类。我们的逻辑中，经常会查出某个表的数据，然后按照这个表的某个字段进行分组。例如，A表，有属性ID和姓名name及其它属性，我们查出一批数据后，想按照name进行分组，生成Map<name,List<A>>这样结构的map。于是，我们写了一段如下的分组代码：

<span style="font-size:18px;">    /**
     * 按name分组方法
     * @param list A表实体的列表
     * @param map 分组后的存储map
     */
    public static void groupA(List<AEntity> list, Map<String, List<AEntity>> map) {
        if (null == list || null == map) {
            return;
        }

        // 按name开始分组
        String key;
        List<AEntity> listTmp;
        for (AEntity val : list) {
            key = val.getName();
            listTmp = map.get(key);
            if (null == listTmp) {
                listTmp = new ArrayList<AEntity>();
                map.put(key, listTmp);
            }
            listTmp.add(val);
        }
    }</span>

        其中，map是调用方new好的HashMap，透传给方法用来承载分组结果的。代码很精简，自我感觉良好。后来又碰到B表，同样的需要查出来，按照某个字段分组，于是就又写了一段代码：

<span style="font-size:18px;">    /**
     * 按age分组方法
     * @param list B表实体的列表
     * @param map 分组后的存储map
     */
    public static void groupB(List<BEntity> list, Map<String, List<BEntity>> map) {
        if (null == list || null == map) {
            return;
        }

        // 按age开始分组
        String key;
        List<AEntity> listTmp;
        for (AEntity val : list) {
            key = val.getAge();
            listTmp = map.get(key);
            if (null == listTmp) {
                listTmp = new ArrayList<AEntity>();
                map.put(key, listTmp);
            }
            listTmp.add(val);
        }
    }</span>

        代码依然精简，但是感觉不太好了。这几乎和前面一个方法一样，能不能精简一下呢？

        于是就各种思考，总结出了几个特点：

        1. 入参泛型不同

        2. 分组的维度（属性方法）不同

        如果能把这两个不同点统一起来，是不是就可以提取一个共同的工具类方法了？

        思路也简单：入参泛型不同，那方法就使用泛型；分组使用的方法不同，就用反射机制，获取方法。于是有了初版的通用方法：

<span style="font-size:18px;">    /**
     * 将List<V>按照V的某个方法返回值（返回值必须为K类型）分组，合入到Map<K, List<V>>中<br>
     * 要保证入参的method必须为V的某一个有返回值的方法，并且该返回值必须为K类型
     * 
     * @param list 待分组的列表
     * @param map 存放分组后的map
     * @param method 方法
     */
    @SuppressWarnings("unchecked")
    public static <K, V> void listGroup2Map(List<V> list, Map<K, List<V>> map, Method method) {
        // 入参非法行校验
        if (null == list || null == map || null == method) {
            LOGGER.error("CommonUtils.listGroup2Map 入参错误，list：" + list + " ；map：" + map
                    + " ；method：" + method);
            return;
        }

        try {
            // 开始分组
            Object key;
            List<V> listTmp;
            for (V val : list) {
                key = method.invoke(val);
                listTmp = map.get(key);
                if (null == listTmp) {
                    listTmp = new ArrayList<V>();
                    map.put((K) key, listTmp);
                }
                listTmp.add(val);
            }
        } catch (Exception e) {
            LOGGER.error("分组失败！", e);
        }
    }

    /**
     * 根据类和方法名，获取方法对象
     * 
     * @param clazz
     * @param methodName
     * @return
     */
    public static Method getMethodByName(Class<?> clazz, String methodName) {
        Method method = null;
        // 入参不能为空
        if (null == clazz || StringUtils.isBlank(methodName)) {
            LOGGER.error("CommonUtils.getMethodByName 入参错误，clazz：" + clazz + " ；methodName："
                    + methodName);
            return method;
        }

        try {
            method = clazz.getDeclaredMethod(methodName);
        } catch (Exception e) {
            LOGGER.error("类获取方法失败！", e);
        }

        return method;
    }</span>

        这两个方法，第二个是为了获取类似getName、getAge之类的方法对象，然后传递给第一个方法即可。（如果大家不想依赖log包之类的，可以将LOGGER处删掉，StringUtils.isBlank方法替换成字符串非空判断即可）

        到这里，我想分享的代码主体思路已经出来了。考虑到让调用者每次都调用两个方法，不太友好，就又改了一版，又补充增加了一个方法：

<span style="font-size:18px;">    /**
     * 将List<V>按照V的methodName方法返回值（返回值必须为K类型）分组，合入到Map<K, List<V>>中<br>
     * 要保证入参的method必须为V的某一个有返回值的方法，并且该返回值必须为K类型
     * 
     * @param list 待分组的列表
     * @param map 存放分组后的map
     * @param clazz 泛型V的类型
     * @param methodName 方法名
     */
    public static <K, V> void listGroup2Map(List<V> list, Map<K, List<V>> map, Class<V> clazz, String methodName) {
        // 入参非法行校验
        if (null == list || null == map || null == clazz || StringUtils.isBlank(methodName)) {
            LOGGER.error("CommonUtils.listGroup2Map 入参错误，list：" + list + " ；map：" + map
                    + " ；clazz：" + clazz + " ；methodName：" + methodName);
            return;
        }

        // 获取方法
        Method method = getMethodByName(clazz, methodName);
        // 非空判断
        if (null == method) {
            return;
        }

        // 正式分组
        listGroup2Map(list, map, method);
    }</span>

        测试方法如下：

<span style="font-size:18px;">    @Test
    public void testGroup() {
        AEntity a1 = new AEntity();
        a1.setId("111");
        a1.setName("name1");
        AEntity a2 = new AEntity();
        a2.setId("222");
        a2.setName("name");
        AEntity a3 = new AEntity();
        a3.setId("111");
        a3.setName("name3");
        AEntity a4 = new AEntity();
        a4.setId("222");
        a4.setName("name");

        List<AEntity> list = new ArrayList<AEntity>();
        list.add(a1);
        list.add(a2);
        list.add(a3);
        list.add(a4);
        list.add(a5);

        System.out.println("list分组前为：" + list);
        Map<String, List<AEntity>> map = new HashMap<String, List<AEntity>>();
        CommonUtils.listGroup2Map(list, map, AEntity.class, "getName");// 输入方法名
        System.out.println("分组完成，分组后的map为：" + map);
    }</span>

        至此，我想分享的代码就出来了。关于性能，我也做了循环10次、100次、1000次、10000次的对比。1000次以下的，耗时差不多，这种通用方式会稍微慢那么一点点（几毫秒）。10000次的差别就有点大了，传统方式耗时3到9ms，通用方式耗时25~78ms不等（毕竟用到反射了）。当然，这个耗时也跟测试样本规模有关，没有深究了。因此，对性能要求非常高的项目，要慎重考虑。

        也许某些开源的工具类中已经有过这样的方法了，不过我没看到，就自己总结了一把，希望对大家有所帮助。

       最后再碎碎念一把：泛型不支持类似V.class这样的调用，不然还能省掉Class<V> clazz这个入参呢。这都是Java向下兼容导致的不便吧！