关于Collections中的sort()方法总结

用Java集合中的Collections.sort方法对list排序的两种方法

本文部分引用自:http://my.oschina.net/leoson/blog/131904

用Collections.sort方法对list排序有两种方法

第一种是list中的对象实现Comparable接口，如下：

User.java

 1 public class User implements Comparable<User>{
 2     //这个地方的Comparable接口后面一定要跟泛型.否则经常编译错误.
 3     private String name;
 4     private Integer order;
 5     public String getName() {
 6         return name;
 7     }
 8     public void setName(String name) {
 9         this.name = name;
10     }
11     public Integer getOrder() {
12         return order;
13     }
14     public void setOrder(Integer order) {
15         this.order = order;
16     }
17     
18     public int compareTo(User user) {
19         return this.getOrder().compareTo(user.getOrder());
20     }
21 }

 

对应的测试类

Test.java

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.List;
 4 
 5 public class Test{
 6     public static void main(String[] args) {
 7         User user1 = new User();
 8         user1.setName("a");
 9         user1.setOrder(1);
10         User user2 = new User();
11         user2.setName("b");
12         user2.setOrder(2);
13         List<User> list = new ArrayList<User>();
14         //此处add user2再add user1
15         list.add(user2);
16         list.add(user1);
17         Collections.sort(list);
18         for(User u : list){
19             System.out.println(u.getName());
20         }
21     }
22 }

 

输出结果

a
b

第二种方法是根据Collections.sort重载方法来实现，例如：

User.java

 1 /**
 2 * 根据order对User排序
 3 */
 4 public class User { //此处无需实现Comparable接口
 5     private String name;
 6     private Integer order;
 7     public String getName() {
 8         return name;
 9     }
10     public void setName(String name) {
11         this.name = name;
12     }
13     public Integer getOrder() {
14         return order;
15     }
16     public void setOrder(Integer order) {
17         this.order = order;
18     }
19 }

 

主类中这样写即可：

Test.java

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.Comparator;
 4 import java.util.List;
 5 
 6 public class Test2{
 7     public static void main(String[] args) {
 8         User user1 = new User();
 9         user1.setName("a");
10         user1.setOrder(1);
11         User user2 = new User();
12         user2.setName("b");
13         user2.setOrder(2);
14         List<User> list = new ArrayList<User>();
15         list.add(user2);
16         list.add(user1);
17          
18         Collections.sort(list,new Comparator<User>(){
19             public int compare(User user1, User user2) {
20                 return user1.getOrder().compareTo(user2.getOrder());
21             }
22         });
23         for(User u : list){
24             System.out.println(u.getName());
25         }
26     }
27 }

 

输出结果

a
b

前者代码结构简单，但是只能根据固定的属性排序，后者灵活，可以临时指定排序项，但是代码不够简洁

多字段的场合： 

Collections.sort(list,new Comparator(){
    public int compare(User arg0, User arg1) {
//            第一次比较专业
        int i = arg0.getOrder().compareTo(arg1.getOrder());

//    如果专业相同则进行第二次比较
    if(i==0){
//        第二次比较
        int j=arg0.getXXX().compareTo(arg1.getXXX());
//        如果学制相同则返回按年龄排序
        if(j==0){
            return arg0.getCCC().compareTo(arg1.getCCC());
        }
        return j;
    }
    return i;
    }
});

 

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

例子二:

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.Comparator;
 4 import java.util.List;
 5 
 6 public class CollectionSortTest {
 7     public static void main(String[] args) {
 8         List<String> lists = new ArrayList<String>();
 9         lists.add("5");
10         lists.add("2");
11         lists.add("9");
12         // lists中的对象String 本身含有compareTo方法，所以可以直接调用sort方法，按自然顺序排序，即升序排序
13         Collections.sort(lists);
14         System.out.println(lists);
15 
16         List<A> list = new ArrayList<A>();
17         A aa = new A();
18         aa.setName("aa");
19         aa.setOrder(1);
20         A bb = new A();
21         bb.setName("bb");
22         bb.setOrder(2);
23         list.add(bb);
24         list.add(aa);
25         // list中的对象A实现Comparable接口
26         Collections.sort(list);
27         System.out.println(list);
28 
29         List<B> listB = new ArrayList<B>();
30         B ab = new B();
31         ab.setName("ab");
32         ab.setOrder("1");
33         B ba = new B();
34         ba.setName("ba");
35         ba.setOrder("2");
36         listB.add(ba);
37         listB.add(ab);
38         // 根据Collections.sort重载方法来实现
39         Collections.sort(listB, new Comparator<B>() {
40             @Override
41             public int compare(B b1, B b2) {
42                 return b1.getOrder().compareTo(b2.getOrder());
43             }
44         });
45 
46         System.out.println(listB);
47     }
48 }
49 
50 class A implements Comparable<A> {
51     private String name;
52     private Integer order;
53     public String getName() {
54         return name;
55     }
56     public void setName(String name) {
57         this.name = name;
58     }
59     public Integer getOrder() {
60         return order;
61     }
62     public void setOrder(Integer order) {
63         this.order = order;
64     }
65     @Override
66     public String toString() {
67         return "name is " + name + " order is " + order;
68     }
69     @Override
70     public int compareTo(A a) {
71         return this.order.compareTo(a.getOrder());
72     }
73 }
74 class B {
75     private String name;
76     private String order;
77     public String getName() {
78         return name;
79     }
80     public void setName(String name) {
81         this.name = name;
82     }
83     public String getOrder() {
84         return order;
85     }
86     public void setOrder(String order) {
87         this.order = order;
88     }
89     @Override
90     public String toString() {
91         return "name is " + name + " order is " + order;
92     }
93 }

打印结果:

[2, 5, 9]
[name is aa order is 1, name is bb order is 2]
[name is ab order is 1, name is ba order is 2]