Java对象比较器对泛型List进行排序-Demo

针对形如：
字段1    字段2     字段3       字段n

1       hello     26          789
1       world     89          556
2       what      55          456
2       the       85          45
2       fuck      55          99
5       haha      98          455

以上类型的查询数据结果，需要对 字段3 进行求和分组（在SQL查询无法一次性完成的情况下，通常采用Java分组排序），大概思路如下：

1、在Bean中添加相关的分组标记字段，对求和或者其它统计的结果进行插入分组标记，下面demo中为bigIdOrder标记

2、对完成标记的List进行标记的补全

3、对补全的List按照标记进行排序

PS：非常不赞成在前端用JS/JQ等进行排序，非常费劲，并且数组还会发生不可知的变化，笔者吃过亏（算法高手除外），笔者编码水平有限，写的不到位的地方恳请大神们批评指正。

因编码直接来源于项目，变量名未做统一demo化，现给出提示：
bigId：字段1
pinci：字段3

bigIdOrder：标记字段（可自定义）

        JSONObject json = new JSONObject();
        String dataType = request.getParameter("dataType");
        String channelId = request.getParameter("channelId");
        String order = request.getParameter("type");
        setMapTimeRight(dataType, 0);

        map.put("channelId", channelId);
        map.put("order", order);

        try {
            List<UnconventionBrandAnalyseByBrand> now = this.service
            .unconventionBrandSituation(map);

            //1、产生组装排序条件字段数据标记
            int bigIdOrder=0;
            int i=-1;
            int i2=0;
            List bigIdOrderArray = new ArrayList();

            for(UnconventionBrandAnalyseByBrand un : now){                
                i++;
                //如果当前bigId与前一个bigId相等,则将该id视为一个id（bigIdOrder），对该id所对应的所有频次数进行累加
                    if(i==0
                            &&now.get(0).getBigId().equals(now.get(1).getBigId())){
                        //第一次计数后有(非分组条件)                                                
                        bigIdOrder = bigIdOrder+Integer.parseInt(now.get(i).getPinci());                        
                    }else if(i>0
                            &&i<now.size()-1
                            &&!now.get(i).getBigId().equals(now.get(i-1).getBigId())
                            &&now.get(i).getBigId().equals(now.get(i+1).getBigId())){
                        //前不同后相同(非分组条件)                        
                        bigIdOrder = bigIdOrder+Integer.parseInt(now.get(i).getPinci());                        
                    }else if(i>0
                            &&i<now.size()-1
                            &&now.get(i).getBigId().equals(now.get(i+1).getBigId())
                            &&now.get(i).getBigId().equals(now.get(i+1).getBigId())){
                        //前相同后相同(非分组条件)                        
                        bigIdOrder = bigIdOrder+Integer.parseInt(now.get(i).getPinci());                        
                    }else{
                        //分组条件
                        bigIdOrder = bigIdOrder+Integer.parseInt(now.get(i).getPinci());

                        un.setBigIdOrder(bigIdOrder+"");//添加分组标识（int类型bigIdOrder）

                        bigIdOrderArray.add(i2, bigIdOrder+"");
                        
                        i2++;
                        bigIdOrder = 0;                        
                    }
                }
            
            
            // 2、补全产生组装排序条件字段数据标记
            int ii = 0;
            int ng = 0;// 非分组条件计数器
            for (UnconventionBrandAnalyseByBrand un : now) {
                // 如果当前bigId与前一个bigId相等,则将该id视为一个id（bigIdOrder），对该id所对应的所有频次数进行累加

                if (ii == 0
                        && !now.get(0).getBigId().equals(now.get(1).getBigId())) {
                    // 第一次计数后无(分组条件)
                } else if (ii > 0
                        && i < now.size() - 1
                        && now.get(ii).getBigId().equals(
                                now.get(ii - 1).getBigId())
                        && !now.get(ii).getBigId().equals(
                                now.get(ii + 1).getBigId())) {
                    // 前同后不同(分组条件)
                } else if (ii == now.size() - 1
                        && now.get(ii).getBigId().equals(
                                now.get(ii - 1).getBigId())) {
                    // 后无前同(分组条件)
                } else if (ii == now.size() - 1
                        && !now.get(ii).getBigId().equals(
                                now.get(ii - 1).getBigId())) {
                    // 后无前不同(分组条件)
                } else {
                    // 非分组条件
                    if (ii == 0) {
                        un.setBigIdOrder(bigIdOrderArray.get(0).toString());
                    } else if (!now.get(ii).getBigId().equals(
                            now.get(ii - 1).getBigId())) {
                        ng++;
                        un.setBigIdOrder(bigIdOrderArray.get(ng).toString());

                    } else {
                        un.setBigIdOrder(bigIdOrderArray.get(ng).toString());
                    }
                }
                ii++;
            }
            
            // 3、开始排序采用对象比较器
            Comparator<UnconventionBrandAnalyseByBrand> comparator = new Comparator<UnconventionBrandAnalyseByBrand>() {
                public int compare(UnconventionBrandAnalyseByBrand s1,
                        UnconventionBrandAnalyseByBrand s2) {
                    // 排序标记
                    int ret = 0;
                    if (s1.getBigIdOrder() != s2.getBigIdOrder()) {
                        ret = Integer.parseInt(s1.getBigIdOrder())
                                - Integer.parseInt(s2.getBigIdOrder());
                    }
                    return ret > 0 ? -1 : 1;// 升序或者降序改变-1和1的位置即可
                }

            };
                
                //开始自动排序
                Collections.sort(now,comparator);

                json.put("data", now);

            try {
                response.setContentType("text/html;charset=UTF-8");
                PrintWriter out = response.getWriter();

                out.print(json);
                out.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;