java双字段分组统计小技巧

待我称王封你为后i 2022-02-25 12:20 417阅读 0赞

**前段时间有人抛出了这样一个问题：**  
这是一个java接口，接受的数据是一个集合List，范型是一个对象，对象有2个重要字段，暂且叫为type1和type2吧，现在需要根据type1和type2分组，并且，当type1为1时，每个50个需要单独一组，最后不足50，单独一个组；type1为2时，每1000个单独一组，最后不足1000一个组

--------------------

**咋一看这样的问题，就是一个统计问题，但是如何用高效的代码去统计，会直接影响着接口的效率问题**  
**首先，我们先来分析一下题目：**  
第一步，我们要把数据分组，必然要循环这个集合List  
第二步，我们要分割数据，按50和1000再分组，再次循环，分割处理

很显然，这样一分析，至少需要循环2次，才能处理出来结果，并且预估要写一堆代码  
**从效率的角度出发，最多只能循环一次，就要搞定，否则接口的性能就不能保证了。。。**  
废话不多说，直接上代码

import com.google.common.collect.Lists;
    import com.google.common.collect.Maps;
    import java.util.List;
    import java.util.Map;
    
    /** * @author yanghao * @version GroupTest.java, v 0.1 2019-04-01 20:24 */
    public class GroupTest { 
    
        public static void main(String[] args){ 
    
            //待处理集合
            List<Group> groupList = buildGroup();
    
            //转换后存储map key = type1_type2_num
            Map<String, List<Group>> goupMap = Maps.newHashMap();
            //记录分组编号 key = type1_type2
            Map<String, Integer> numMap = Maps.newHashMap();
    
            //map的key组合
            String mapkey = "";
            //按照50和1000分组编号
            int index;
            //每个type1和type2分组后的集合
            List<Group> glist = null;
    
            //开始循环处理数据。。。
            for(Group group : groupList){ 
                mapkey = group.getType1() + "_" + group.getType2();
    
                //==============1.查询小分组编号==============
                if(numMap.get(mapkey) == null){ 
                    index = 1;
                    numMap.put(mapkey, index);
                }else { 
                    index = numMap.get(mapkey);
                }
    
                //==============2.查询小分组集合==============
                //小分组key
                mapkey += "_" + index;
    
                if(goupMap.get(mapkey) == null){ 
                    glist = Lists.newArrayList();
                }else { 
                    glist = goupMap.get(mapkey);
                }
    
                //==============3.放入goupMap==============
                glist.add(group);
                goupMap.put(mapkey, glist);
    
                //==============4.判断小分组是否超过分组上限==============
                if((group.getType1() == 1 && glist.size() >= 50) ||
                        (group.getType1() == 2 && glist.size() >= 1000)) { 
    
                    //分组编号加1后重新放入编号map
                    index ++;
                    numMap.put(group.getType1() + "_" + group.getType2(), index);
                }
    
            }
    
            System.out.println("goupMap == " + goupMap);
    
        }
    
        /** * 组建测试数据 * @return */
        private static List<Group> buildGroup() { 
            List<Group> groupList = Lists.newArrayList();
    
            Group group1 = new Group();
            group1.setType1(1);
            group1.setType2("a");
            groupList.add(group1);
    
            Group group2 = new Group();
            group2.setType1(1);
            group2.setType2("b");
            groupList.add(group2);
    
            Group group3 = new Group();
            group3.setType1(2);
            group3.setType2("c");
            groupList.add(group3);
    
            Group group4 = new Group();
            group4.setType1(2);
            group4.setType2("c");
            groupList.add(group4);
    
            return groupList;
        }
    
    }

运行结果如下：

goupMap == { 2_c_1=[Group(type1=2, type2=c), Group(type1=2, type2=c)], 1_b_1=[Group(type1=1, type2=b)], 1_a_1=[Group(type1=1, type2=a)]}

可以看出，基本已经按照type1和type2进行分组了

**再来验证一下，上限50和1000，由于测试数据不多，将1000改为了1，进行了测试，结果如下：**

goupMap == { 2_c_2=[Group(type1=2, type2=c)], 2_c_1=[Group(type1=2, type2=c)], 1_b_1=[Group(type1=1, type2=b)], 1_a_1=[Group(type1=1, type2=a)]}

从结果看出，上限的效果也达到了，达到1时，分组为由2\_c\_1变为2\_c\_2了。。。

--------------------

**有的时候，有些办法不可行的时候，我们可以转换我们的思路，很好的利用Map实现了我们想要的，我们要学会转换我们的思想，做事会事半功倍的！**