关于java sort的几种实现方式（单纯排序，按照bean的某一个字段，按照bean的多个字段）

最近的开发过程中遇到了，按照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) {

        //１、単純なリストをソートする例
        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のある属性をキーとしてソートする例
        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の複数属性をキーとしてソートする例
        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) {

        // 検索結果リスト対象またはソースパラメータ対象がNULLである場合
        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