最近的開發過程中遇到了，按照bean類中的多個欄位進行排序的情況，藉此機會把相關的排序做法，簡單整理備份一下。

1.list的單純排序

2.list元素為bean的情況，按照bean的某一個屬性進行排序

3.list元素為bean的情況，按照bean的多個屬性進行排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import cn.com.ydd.bean.SortBean;
 
import cn.com.ydd.util.CommonUtil;

public class SortTest {
    public static void main(String[] args) {
        
        //１、單純的一個list資料排序
        ArrayList lst = new ArrayList();
        lst.add("00000000001");
        lst.add("00000000002");
        lst.add("00000000003");
        lst.add("00000000004");
        lst.add("00000000005");
        //升序排序
 

        Collections.sort(lst);
        System.out.println(lst.toString());
        //降序排序
        Collections.reverse(lst);
        System.out.println(lst.toString());
        //２、list元素為Bean的情況下，根據Bean裡面一個元素排序
        List<SortBean> list = new ArrayList<SortBean>();
        SortBean sb;
        sb 
 
= new SortBean();
        sb.setId("00001");
        sb.setName("田中");
        sb.setSex("F");
        list.add(sb);
        
        sb = new SortBean();
        sb.setId("00002");
        sb.setName("佐藤");
        sb.setSex("M");
        list.add(sb);
        
        sb = new SortBean();
        sb.setId("00003");
        sb.setName("佐藤");
        sb.setSex("M");
        list.add(sb);
        
        sb = new SortBean();
        sb.setId("00004");
        sb.setName("佐藤");
        sb.setSex("M");
        list.add(sb);
        
        
        sb = new SortBean();
        sb.setId("00005");
        sb.setName("山本");
        sb.setSex("F");
        list.add(sb);
        
        sb = new SortBean();
        sb.setId("00006");
        sb.setName("山本");
        sb.setSex("F");
        list.add(sb);
        
        //降順
        System.out.println("***********name:降順*************");
        CommonUtil.sort(list, "name", false);
        for(SortBean item : list){
            System.out.print(item.getId()+"    ");
            System.out.print(item.getName()+"    ");
            System.out.println(item.getSex());
        }
        //升序
        System.out.println("***********name:昇順*************");
        CommonUtil.sort(list, "name", true);
        for(SortBean item : list){
            System.out.print(item.getId()+"    ");
            System.out.print(item.getName()+"    ");
            System.out.println(item.getSex());
        }
        
        System.out.println("***********name：昇順　ID：降順*************");
        //３、list元素為Bean的情況下，根據Bean裡面多個元素排序
        Map<String, String> sortParam = new LinkedHashMap<String, String>();
        //name：升序　ID：降序
        sortParam.put("name", "asc");
        sortParam.put("id", "desc");
        CommonUtil.sortExecute(list, sortParam);
        
        for(SortBean item : list){
            System.out.print(item.getId()+"    ");
            System.out.print(item.getName()+"    ");
            System.out.println(item.getSex());
        }
        sortParam.clear();
        //name：降序　ID：升序
        sortParam.put("name", "desc");
        sortParam.put("id", "asc");
        CommonUtil.sortExecute(list, sortParam);
        System.out.println("***********name：降順　ID：昇順*************");
        for(SortBean item : list){
            System.out.print(item.getId()+"    ");
            System.out.print(item.getName()+"    ");
            System.out.println(item.getSex());
        }
    }
}

共通方法類

import java.util.Comparator;
import java.util.List;
import java.util.Map;

import org.apache.commons.beanutils.BeanComparator;
import org.apache.commons.collections4.ComparatorUtils;
import org.apache.commons.collections4.comparators.ComparableComparator;
import org.apache.commons.collections4.comparators.ComparatorChain;
import org.apache.commons.collections4.comparators.NullComparator;

public class CommonUtil {

    /**
     * 根據Bean下面的一個元素排序
     * @param list
     * @param filedName
     * @param ascFlag
     */
    @SuppressWarnings("unchecked")
    public static void sort(List list, String filedName, boolean ascFlag) {

        if (list.size() == 0 || filedName.equals("")) {
            return;
        }
        Comparator<?> cmp = ComparableComparator.INSTANCE;
        // 降序
        if (ascFlag) {
            cmp = ComparatorUtils.nullLowComparator(cmp);
        } else {

            cmp = ComparatorUtils.reversedComparator(cmp);

        }
        Collections.sort(list, new BeanComparator(filedName, cmp));
    }
    
    /**
     * 根據Bean下面的多個元素排序
     * @param beans
     * @param sortParam
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void sortExecute(List<?> beans, Map<String, String> sortParam) {

        if (beans.size() == 0 || sortParam.keySet().size() == 0) {
            return;
        }
        if (beans.isEmpty() || sortParam.isEmpty()) {
            return;
        }
        ComparatorChain comparator = new ComparatorChain();
        boolean sortMethod = false;
        for (String itemName : sortParam.keySet()) {
            sortMethod = false;
            if ("desc".equals(sortParam.get(itemName))) {
                sortMethod = true;
            }
            comparator.addComparator(new BeanComparator(itemName, new NullComparator()), sortMethod);
        }
        Collections.sort(beans, comparator);
    }

}

 輸出結果

[00000000001, 00000000002, 00000000003, 00000000004, 00000000005]
[00000000005, 00000000004, 00000000003, 00000000002, 00000000001]
***********name:降順*************
00001    田中    F
00005    山本    F
00006    山本    F
00002    佐藤    M
00003    佐藤    M
00004    佐藤    M
***********name:昇順*************
00002    佐藤    M
00003    佐藤    M
00004    佐藤    M
00005    山本    F
00006    山本    F
00001    田中    F
***********name：昇順　ID：降順*************
00004    佐藤    M
00003    佐藤    M
00002    佐藤    M
00006    山本    F
00005    山本    F
00001    田中    F
***********name：降順　ID：昇順*************
00001    田中    F
00005    山本    F
00006    山本    F
00002    佐藤    M
00003    佐藤    M
00004    佐藤    M