关于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]