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

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

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

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

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

User.java

 public class User implements Comparable<User>{
     //这个地方的Comparable接口后面一定要跟泛型.否则经常编译错误.
     private String name;
     private Integer order;
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public Integer getOrder() {
         return order;
     }
     public void setOrder(Integer order) {
         this.order = order;
     }

     public int compareTo(User user) {
         return this.getOrder().compareTo(user.getOrder());
     }
 }

对应的测试类

Test.java

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;

 public class Test{
     public static void main(String[] args) {
         User user1 = new User();
         user1.setName("a");
         user1.setOrder(1);
         User user2 = new User();
         user2.setName("b");
         user2.setOrder(2);
         List<User> list = new ArrayList<User>();
         //此处add user2再add user1
         list.add(user2);
         list.add(user1);
         Collections.sort(list);
         for(User u : list){
             System.out.println(u.getName());
         }
     }
 }

输出结果

a
b

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

User.java

 /**
 * 根据order对User排序
 */
 public class User { //此处无需实现Comparable接口
     private String name;
     private Integer order;
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public Integer getOrder() {
         return order;
     }
     public void setOrder(Integer order) {
         this.order = order;
     }
 }

主类中这样写即可：

Test.java

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;

 public class Test2{
     public static void main(String[] args) {
         User user1 = new User();
         user1.setName("a");
         user1.setOrder(1);
         User user2 = new User();
         user2.setName("b");
         user2.setOrder(2);
         List<User> list = new ArrayList<User>();
         list.add(user2);
         list.add(user1);

         Collections.sort(list,new Comparator<User>(){
             public int compare(User user1, User user2) {
                 return user1.getOrder().compareTo(user2.getOrder());
             }
         });
         for(User u : list){
             System.out.println(u.getName());
         }
     }
 }

输出结果

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;
    }
});

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

例子二:

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;

 public class CollectionSortTest {
     public static void main(String[] args) {
         List<String> lists = new ArrayList<String>();
         lists.add("5");
         lists.add("2");
         lists.add("9");
         // lists中的对象String 本身含有compareTo方法，所以可以直接调用sort方法，按自然顺序排序，即升序排序
         Collections.sort(lists);
         System.out.println(lists);

         List<A> list = new ArrayList<A>();
         A aa = new A();
         aa.setName("aa");
         aa.setOrder(1);
         A bb = new A();
         bb.setName("bb");
         bb.setOrder(2);
         list.add(bb);
         list.add(aa);
         // list中的对象A实现Comparable接口
         Collections.sort(list);
         System.out.println(list);

         List<B> listB = new ArrayList<B>();
         B ab = new B();
         ab.setName("ab");
         ab.setOrder("1");
         B ba = new B();
         ba.setName("ba");
         ba.setOrder("2");
         listB.add(ba);
         listB.add(ab);
         // 根据Collections.sort重载方法来实现
         Collections.sort(listB, new Comparator<B>() {
             @Override
             public int compare(B b1, B b2) {
                 return b1.getOrder().compareTo(b2.getOrder());
             }
         });

         System.out.println(listB);
     }
 }

 class A implements Comparable<A> {
     private String name;
     private Integer order;
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public Integer getOrder() {
         return order;
     }
     public void setOrder(Integer order) {
         this.order = order;
     }
     @Override
     public String toString() {
         return "name is " + name + " order is " + order;
     }
     @Override
     public int compareTo(A a) {
         return this.order.compareTo(a.getOrder());
     }
 }
 class B {
     private String name;
     private String order;
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getOrder() {
         return order;
     }
     public void setOrder(String order) {
         this.order = order;
     }
     @Override
     public String toString() {
         return "name is " + name + " order is " + order;
     }
 }

打印结果:

[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]