List集合中的元素进行排序

Collections对List集合中的数据进行排序

有时候需要对集合中的元素按照一定的规则进行排序，这就需要用到
Java中提供的对集合进行操作的工具类Collections，其中的sort方法

 1 package com.kaishengit;
 2 
 3 import java.util.Arrays;
 4 import java.util.Collections;
 5 import java.util.List;
 6 /**
 7  * @author Wgs
 8  * @version 1.0
 9  * @create：2018/04/28
10  */
11 public class SortDemo {
12     public static void main(String[] args) {
13         List<Integer> srs = Arrays.asList(5,2,9,3,4);
14         System.out.println("----排序前----");
15         // 5 2 9 3 4
16         prints(srs);
17         // 排序
18         Collections.sort(srs);
19         System.out.println("----排序后----");
20         // 2 3 4 5 9
21         prints(srs);
22     }
23 
24     private static void prints(List<Integer> srs) {
25         for (Integer s : srs){
26             System.out.println(s);
27         }
28     }
29 }

结果

稍微复杂的List里面放一个复杂的对象

 1 package com.kaishengit;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collections;
 5 import java.util.List;
 6 
 7 /**
 8  * @author Wgs
 9  * @version 1.0
10  * @create：2018/04/28
11  */
12 public class User implements Comparable<User> {
13     private int age;
14     private int score;
15 
16     public User(int age, int score) {
17         this.age = age;
18         this.score = score;
19     }
20 
21     public int getAge() {
22         return age;
23     }
24 
25     public void setAge(int age) {
26         this.age = age;
27     }
28 
29     public int getScore() {
30         return score;
31     }
32 
33     public void setScore(int score) {
34         this.score = score;
35     }
36 
37     @Override
38     public int compareTo(User o) {
39         // 先按照年龄排序
40         int i = this.getAge() - o.age;
41         // 年龄相等按照成绩排序
42         if (i == 0) {
43             i = this.getScore() - o.getScore();
44         }
45         return i;
46     }
47 
48     public static void main(String[] args) {
49         List<User> users = new ArrayList<User>();
50         users.add(new User(78, 26));
51         users.add(new User(67, 23));
52         users.add(new User(34, 56));
53         users.add(new User(55, 23));
54         Collections.sort(users);
55         for (User user : users) {
56             System.out.println(user.getScore() + "," + user.getAge());
57         }
58 
59         /**
60          * 56,34
61          * 23,55
62          * 23,67
63          * 26,78
64          */
65     }
66 }

我们会发现sort(List<T>)方法中List中的T必须实现Comparable<T>接口，然后实现compareTo（）方法，该方法的返回值0代表相等，1表示大于，-1表示小于；为什么在简单例子中没有看到实现Comparable接口呢？是因为Integer类其实自己已经实现了Comparable接口，Java已经给我们做好了。

Collections提供的第二种排序方法sort(List<T> list, Comparator<? super T> c)

 1 package com.kaishengit;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collections;
 5 import java.util.Comparator;
 6 import java.util.List;
 7 
 8 /**
 9  * @author Wgs
10  * @version 1.0
11  * @create：2018/04/28
12  */
13 public class User {
14     private int age;
15     private int score;
16 
17     public User(int age, int score) {
18         this.age = age;
19         this.score = score;
20     }
21 
22     public int getAge() {
23         return age;
24     }
25 
26     public void setAge(int age) {
27         this.age = age;
28     }
29 
30     public int getScore() {
31         return score;
32     }
33 
34     public void setScore(int score) {
35         this.score = score;
36     }
37 
38 
39     public static void main(String[] args) {
40         List<User> users = new ArrayList<User>();
41         users.add(new User(78, 26));
42         users.add(new User(67, 23));
43         users.add(new User(34, 56));
44         users.add(new User(55, 23));
45         Collections.sort(users, new Comparator<User>() {
46             @Override
47             public int compare(User o1, User o2) {
48                 int i = o1.getScore() - o2.getScore();
49                 if(i == 0){
50                     return o1.getAge() - o2.getAge();
51                 }
52                 return i;
53             }
54         });
55         for (User user : users) {
56             System.out.println(user.getScore() + "," + user.getAge());
57         }
58 
59         /**
60          * 56,34
61          * 23,55
62          * 23,67
63          * 26,78
64          */
65     }
66 }

从上面的例子我们可以看出Students类没有实现Comparable<T>接口，只是在sort()方法
中多传入一个参数，只不过该参数是一个接口我们需要实现其compare方法。