用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, 曹操, 曹操到, 关羽, 刘邦, 项羽, 赵高, 赵云, 诸葛亮]
排序规则是：数字排在最前，英文字母其次，汉字则按照拼音进行排序。
原文地址：https://www.cnblogs.com/oablog/p/9342233.html
时间： 2024-10-10 15:10:49