通过Java排序List集合的元素的几种方法

用Java工具类Collections的sort()方法，对List集合元素进行排序。

Collections提供两种排序方法：

一、Collections.sort(List<T> list);

　　此方法需要泛型T这个Bean实现Comparable<T>接口，并且实现compareTo()方法排序；

二、Collections.sort(List<T> list, Comparator<? super T> c);

　　此方法，在泛型T这个Bean没有实现Comparable<T>接口的时候，多个一个参数，是一个接口我们需要实现其compare()方法排序；

排序List集合里面的元素，例如：

/**
* 简单的Collection排序
*/
public static void simpleSort() {
    List<String> sortElement = new ArrayList<>();
    sortElement.add("A");
    sortElement.add("D");
    sortElement.add("R");
    sortElement.add("T");
    sortElement.add("F");
    System.out.println("未排序之前的List：" + sortElement);
    Collections.sort(sortElement);
    System.out.println("排序之后的List：" + sortElement);
}

输出结果：

未排序之前的List：[A, D, R, T, F]
排序之后的List：[A, D, F, R, T]

由于String类其实自身已经实现了Comparable接口，Java已经帮我们封装好了，所以我们不需要再实现compareTo()方法；

下面来看下，新建一个Bean，实现Comparable<T>接口，并且实现compareTo()方法来自定义排序。例如：

新建Bean：JavaProgrammer ：

package com.max.basis;

import java.io.Serializable;

/**
 * Java程序员
 * @author Max.
 * @date 2018/7/20
 */
public class JavaProgrammer implements Comparable<JavaProgrammer>, Serializable {
    /**
     * 姓名
     */
    private String name;
    /**
     * 工资
     */
    private int wage;
    /**
     * 年龄
     */
    private int age;

    @Override
    public int compareTo(JavaProgrammer o) {
        // 首先根据年龄排序
        int sort = this.getAge() - o.getAge();
        // 返回值0代表相等，1表示大于，-1表示小于；
        if (sort == 0) {
            // 在根据工资排序
            return this.getWage() - o.getWage();
        }
        return sort;
    }

    public JavaProgrammer(String name, int wage, int age) {
        this.name = name;
        this.wage = wage;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getWage() {
        return wage;
    }

    public void setWage(int wage) {
        this.wage = wage;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

/**
* Bean实现Comparable接口，实现compareTo()方法来排序
*/
public static void sortBeans() {
    List<JavaProgrammer> sortBeans = new ArrayList<>();
    sortBeans.add(new JavaProgrammer("A", 20000, 20));
    sortBeans.add(new JavaProgrammer("B", 55000, 21));
    sortBeans.add(new JavaProgrammer("C", 65000, 20));
    sortBeans.add(new JavaProgrammer("D", 120000, 28));
    sortBeans.add(new JavaProgrammer("E", 90000, 23));
    Collections.sort(sortBeans);
    for (JavaProgrammer javaProgrammer : sortBeans) {
        System.out.println("姓名：" + javaProgrammer.getName()
            + ",工资：" + javaProgrammer.getWage()
            + ",年龄：" + javaProgrammer.getAge());
    }
}

输出结果：

姓名：A,工资：20000,年龄：20
姓名：C,工资：65000,年龄：20
姓名：B,工资：55000,年龄：21
姓名：E,工资：90000,年龄：23
姓名：D,工资：120000,年龄：28

看到上面的Bean，实现了Comparable<T>接口，并且实现compareTo()方法，首先根据年龄大小排序，如果年龄相等，在根据工资大小排序；

再看不在Bean里面实现Comparable<T>接口，在需要用到排序的时候，用Collections.sort(List<T> list, Comparator<? super T> c)方法排序，例如：

新建Bean：TestBean ：

package com.max.basis;

import java.io.Serializable;

/**
 * 测试类
 * @author Max.
 * @date 2018/7/20
 */
public class TestBean implements Serializable {

    private Integer age;

    private Integer score;

    public TestBean(Integer age, Integer score) {
        this.age = age;
        this.score = score;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getScore() {
        return score;
    }

    public void setScore(Integer score) {
        this.score = score;
    }
}

/**
* 在Collection排序的时候给人Comparator参数
*/
private static void sortTestBean() {
    List<TestBean> sortList = new ArrayList<>();
    sortList.add(new TestBean(18, 402));
    sortList.add(new TestBean(18, 512));
    sortList.add(new TestBean(17, 633));
    sortList.add(new TestBean(19, 497));
    Collections.sort(sortList, new Comparator<TestBean>() {
        @Override
        public int compare(TestBean o2, TestBean o1) {
            int sort = o1.getAge() - o2.getAge();
            if (sort == 0) {
                return o1.getScore() - o2.getScore();
            }
            return sort;
        }
    });
    for (TestBean testBean : sortList) {
        System.out.println("年龄：" + testBean.getAge() 
            + "，总分：" + testBean.getScore());
    }
}

输出结果：

年龄：19，总分：497
年龄：18，总分：512
年龄：18，总分：402
年龄：17，总分：633

 注意：如果需要排序或者降序，只需要把o1.getAge() - o2.getAge()两个互换位置就可以了。

然而上面的例子只是对List集合的英文及数字排序，再来看看Collections.sort 中文排序。

public static void sortString(){
    List<String> sortStringList = new ArrayList<>();
    sortStringList.add("刘邦");
    sortStringList.add("项羽");
    sortStringList.add("关羽");
    sortStringList.add("赵云");
    sortStringList.add("诸葛亮");
    sortStringList.add("曹操");
    sortStringList.add("曹操到");
    sortStringList.add("LOL");
    sortStringList.add("赵高");
    sortStringList.add("10086");
    System.out.println("未排序之前的List：" + sortStringList);
    Comparator<String> comparator = new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            Collator collator = Collator.getInstance();
            return collator.getCollationKey(o1).compareTo(collator.getCollationKey(o2));
        }
    };
    Collections.sort(sortStringList,comparator);
    System.out.println("排序之后的List：" + sortStringList);
}

输出结果：

未排序之前的List：[刘邦, 项羽, 关羽, 赵云, 诸葛亮, 曹操, 曹操到, LOL, 赵高, 10086]
排序之后的List：[10086, LOL, 曹操, 曹操到, 关羽, 刘邦, 项羽, 赵高, 赵云, 诸葛亮]

排序规则是：数字排在最前，英文字母其次，汉字则按照拼音进行排序。