通過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集合裏面的元素，例如：

 1 /**
 2 * 簡單的Collection排序
 3 */
 4 public static void simpleSort() {
 5     List<String> sortElement = new ArrayList<>();
 6     sortElement.add("A");
 7     sortElement.add("D");
 8     sortElement.add("R");
 9     sortElement.add("T");
10     sortElement.add("F");
11     System.out.println("未排序之前的List：" + sortElement);
12     Collections.sort(sortElement);
13     System.out.println("排序之後的List：" + sortElement);
14 }

輸出結果：

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

由於String類其實自身已經實現了Comparable接口，Java已經幫我們封裝好了，所以我們不需要再實現compareTo()方法；

下面來看下，新建一個Bean，實現Comparable<T>接口，並且實現compareTo()方法來自定義排序。例如：

新建Bean：JavaProgrammer ：

 1 package com.max.basis;
 2 
 3 import java.io.Serializable;
 4 
 5 /**
 6  * Java程序員
 7  * @author Max.
 8  * @date 2018/7/20
 9  */
10 public class JavaProgrammer implements Comparable<JavaProgrammer>, Serializable {
11     /**
12      * 姓名
13      */
14     private String name;
15     /**
16      * 工資
17      */
18     private int wage;
19     /**
20      * 年齡
21      */
22     private int age;
23 
24     @Override
25     public int compareTo(JavaProgrammer o) {
26         // 首先根據年齡排序
27         int sort = this.getAge() - o.getAge();
28         // 返回值0代表相等，1表示大於，-1表示小於；
29         if (sort == 0) {
30             // 在根據工資排序
31             return this.getWage() - o.getWage();
32         }
33         return sort;
34     }
35 
36     public JavaProgrammer(String name, int wage, int age) {
37         this.name = name;
38         this.wage = wage;
39         this.age = age;
40     }
41 
42     public String getName() {
43         return name;
44     }
45 
46     public void setName(String name) {
47         this.name = name;
48     }
49 
50     public int getWage() {
51         return wage;
52     }
53 
54     public void setWage(int wage) {
55         this.wage = wage;
56     }
57 
58     public int getAge() {
59         return age;
60     }
61 
62     public void setAge(int age) {
63         this.age = age;
64     }
65 }

 1 /**
 2 * Bean實現Comparable接口，實現compareTo()方法來排序
 3 */
 4 public static void sortBeans() {
 5     List<JavaProgrammer> sortBeans = new ArrayList<>();
 6     sortBeans.add(new JavaProgrammer("A", 20000, 20));
 7     sortBeans.add(new JavaProgrammer("B", 55000, 21));
 8     sortBeans.add(new JavaProgrammer("C", 65000, 20));
 9     sortBeans.add(new JavaProgrammer("D", 120000, 28));
10     sortBeans.add(new JavaProgrammer("E", 90000, 23));
11     Collections.sort(sortBeans);
12     for (JavaProgrammer javaProgrammer : sortBeans) {
13         System.out.println("姓名：" + javaProgrammer.getName()
14             + ",工資：" + javaProgrammer.getWage()
15             + ",年齡：" + javaProgrammer.getAge());
16     }
17 }

輸出結果：

姓名：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 ：

 1 package com.max.basis;
 2 
 3 import java.io.Serializable;
 4 
 5 /**
 6  * 測試類
 7  * @author Max.
 8  * @date 2018/7/20
 9  */
10 public class TestBean implements Serializable {
11 
12     private Integer age;
13 
14     private Integer score;
15 
16     public TestBean(Integer age, Integer score) {
17         this.age = age;
18         this.score = score;
19     }
20 
21     public Integer getAge() {
22         return age;
23     }
24 
25     public void setAge(Integer age) {
26         this.age = age;
27     }
28 
29     public Integer getScore() {
30         return score;
31     }
32 
33     public void setScore(Integer score) {
34         this.score = score;
35     }
36 }

 1 /**
 2 * 在Collection排序的時候給人Comparator參數
 3 */
 4 private static void sortTestBean() {
 5     List<TestBean> sortList = new ArrayList<>();
 6     sortList.add(new TestBean(18, 402));
 7     sortList.add(new TestBean(18, 512));
 8     sortList.add(new TestBean(17, 633));
 9     sortList.add(new TestBean(19, 497));
10     Collections.sort(sortList, new Comparator<TestBean>() {
11         @Override
12         public int compare(TestBean o2, TestBean o1) {
13             int sort = o1.getAge() - o2.getAge();
14             if (sort == 0) {
15                 return o1.getScore() - o2.getScore();
16             }
17             return sort;
18         }
19     });
20     for (TestBean testBean : sortList) {
21         System.out.println("年齡：" + testBean.getAge() 
22             + "，總分：" + testBean.getScore());
23     }
24 }

輸出結果：

年齡：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, 曹操, 曹操到, 關羽, 劉邦, 項羽, 趙高, 趙雲, 諸葛亮]

排序規則是：數字排在最前，英文字母其次，漢字則按照拼音進行排序。