在應用開發的時候，我們有時候會遇到需要對一個給定集合進行分組的情況。如果該集合的資料記錄是從資料庫的獲取，通常我們最簡單的方案是直接在sql層面select後group by完成。 但是，假如某些場景下該資料不是從資料庫獲取呢？那就需要在應用程式層面進行分組。

假設給定一個集合，{A:5,A:4,A:3,B:6,B:7}， 需要對其進行分組，使其結果是 {A:[5,4,3],B:[6,7]}。

下面是常規的寫法：

//1)對集合進行分組
public Map<String,List<TspPefScoreCalTotal>> groupListByFields(List
 
<TspPefScoreCalTotal> list){

        Map<String,List<TspPefScoreCalTotal>> resultMap = new HashMap<String,List<TspPefScoreCalTotal>>();
        String groupKey = null;
        for(TspPefScoreCalTotal obj : list){
            groupKey = formatGroupKeyByFields(obj);
            if
 
 (resultMap.containsKey(groupKey)) {
                resultMap.get(groupKey).add(obj);
            } else {
                List<TspPefScoreCalTotal> pefScoreCalTotalList = new ArrayList<TspPefScoreCalTotal>();
                pefScoreCalTotalList.add(obj);
                resultMap.put(groupKey, pefScoreCalTotalList);
            }
        }
        return
 
 resultMap;

    }

//2)構造分組的關鍵字
private String formatGroupKeyByFields(TspPefScoreCalTotal obj) {
        return new StringBuilder().append(obj.getBuyerCompanyId()).append("-").append(obj.getOrganizationId()).toString();
    }

上面的例子1）方法就hardcode了List集合裡的物件是TspPefScoreCalTotal，這樣就使得程式不具有通用性。試試想，下一次是其它資料物件呢？那豈不是重複寫上面相似的程式碼？ 還有，2）方法裡的分組的關鍵字隨業務變化而調整呢？ 那豈不是要改方法裡的組合欄位？

基於Java設計模式的開放封閉原則。如果要寫通用程式，嘗試使用java的反射機制，使其可以讓呼叫者輸入任意的物件，且可以任意指定按照哪些欄位進行分組。下面給出具體實現例子。

public class GroupUtil<T> {

    private String formatGroupKeyByFields(T obj, List<String> fields) {
        StringBuilder strBu =  new StringBuilder();
        for(String field : fields){
            strBu.append(getFieldValueByName(field,obj)).append("-");
        }
        return strBu.toString();
    }

    public Map<String,List<T>> groupListByFields(List<T> list, Class ObjClazz, List<String> fields){
        Map<String,List<T>> resultMap = new HashMap<String,List<T>>();
        String groupKey = null;
        for(T obj : list){ 
            groupKey = formatGroupKeyByFields(obj,fields);
            if (resultMap.containsKey(groupKey)) {
                resultMap.get(groupKey).add(obj);
            } else {
                List<T> objectList = new ArrayList<T>();
                objectList.add(obj);
                resultMap.put(groupKey, objectList);
            }
        }
        return resultMap;
    }

    /**
     * 根據屬性名獲取屬性值
     * */
    public Object getFieldValueByName(String fieldName, Object o) {
        try {
            String firstLetter = fieldName.substring(0, 1).toUpperCase();
            String getter = "get" + firstLetter + fieldName.substring(1);
            Method method = o.getClass().getMethod(getter, new Class[] {});
            Object value = method.invoke(o, new Object[] {});
            return value;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        //構造測試例子start
        GroupUtil<TspPefScoreCalTotal> testGroup = new GroupUtil<TspPefScoreCalTotal>();
        TspPefScoreCalTotal t1 = new TspPefScoreCalTotal();
        TspPefScoreCalTotal t2 = new TspPefScoreCalTotal();
        TspPefScoreCalTotal t3 = new TspPefScoreCalTotal();
        TspPefScoreCalTotal t4 = new TspPefScoreCalTotal();
        t1.setPefTotalScoreId(1L);
        t1.setBuyerCompanyId(1L);
        t1.setOrganizationId(9L);
        t1.setTotalScore(10L);
        t2.setPefTotalScoreId(2L);
        t2.setBuyerCompanyId(2L);
        t2.setOrganizationId(9L);
        t2.setTotalScore(5L);
        t3.setPefTotalScoreId(3L);
        t3.setBuyerCompanyId(1L);
        t3.setOrganizationId(9L);
        t3.setTotalScore(20L);
        t4.setPefTotalScoreId(4L);
        t4.setBuyerCompanyId(1L);
        t4.setOrganizationId(9L);
        t4.setTotalScore(20L);

        List<TspPefScoreCalTotal> list = new ArrayList<TspPefScoreCalTotal>();
        list.add(t1);
        list.add(t2);
        list.add(t3);
        list.add(t4);
        //構造測試例子end


        System.out.println("===================通用分組=======================");

        List<String> fields = new LinkedList<String>();
        fields.add("buyerCompanyId");//指定分組欄位
        fields.add("organizationId");//指定分組欄位
        Map<String, List<TspPefScoreCalTotal>> rstMap2 = testGroup.groupListByFields(list,TspPefScoreCalTotal.class,fields);
        for( Entry<String,List<TspPefScoreCalTotal>> entryTemp : rstMap2.entrySet()){
            System.out.println(entryTemp.getKey());
            for(TspPefScoreCalTotal obj : entryTemp.getValue()){
                System.out.println(testGroup.getFieldValueByName("pefTotalScoreId", obj));
            }
        }
    }

}

public class TspPefScoreCalTotal {

private Long pefTotalScoreId; //主鍵ID
private Long totalScore; //得分
private Long totalScoreRanking; //排列名次
private Long buyerCompanyId; //公司
private Long organizationId; //工廠

public Long getPefTotalScoreId() {
        return this.pefTotalScoreId;
    }
public void setPefTotalScoreId (Long pefTotalScoreId) {
        this.pefTotalScoreId = pefTotalScoreId;
    }
public Long getTotalScore() {
        return this.totalScore;
    }
public void setTotalScore (Long totalScore) {
        this.totalScore = totalScore;
    }
public Long getTotalScoreRanking() {
        return this.totalScoreRanking;
    }
public void setTotalScoreRanking (Long totalScoreRanking) {
        this.totalScoreRanking = totalScoreRanking;
    }   
public Long getBuyerCompanyId() {
        return this.buyerCompanyId;
    }
public void setBuyerCompanyId (Long buyerCompanyId) {
        this.buyerCompanyId = buyerCompanyId;
    }

public Long getOrganizationId() {
        return this.organizationId;
    }

public void setOrganizationId (Long organizationId) {
        this.organizationId = organizationId;
    }
}   

當然，上面的程式還沒有考慮對於大資料量時候的分組處理是否有效能問題。下回找個時間測試一下。