Comparable和Comparator接口

工作中偶然遇到了这个问题，需要根据某个类的某个成员变量来进行排序，然后就发现了Java中的这两个接口，Comparable和Comparator，本着求根问底的精神，今天把这里整理一下。

1、Comparable接口

  先看看Java中的源码（摘取一段注释）

 * This interface imposes a total ordering on the objects of each class that
 * implements it.  This ordering is referred to as the class's <i>natural
 * ordering</i>, and the class's <tt>compareTo</tt> method is referred to as
 * its <i>natural comparison method</i>.<p>

这个接口给每个实现它的类都“impose”了一个total ordering。这种ordering可以理解成这个类的“natural ordering”，这个natural ordering就是通过调用compareTo方法来实现的。

再接着看下面这一段

 * Lists (and arrays) of objects that implement this interface can be sorted
 * automatically by {@link Collections#sort(List) Collections.sort} (and
 * {@link Arrays#sort(Object[]) Arrays.sort}).  Objects that implement this
 * interface can be used as keys in a {@linkplain SortedMap sorted map} or as
 * elements in a {@linkplain SortedSet sorted set}, without the need to
 * specify a {@linkplain Comparator comparator}.<p>

所有实现了Comparable接口的这种类的对象的List可以直接使用Collections.sort(lis)来进行排序，而且实现了这个接口的对象可以作为SortedMap或者SortedSet的key而不需要再实现Comparator

举个例子

定义一个Student类：

class Student implements Comparable<Student>{
	public Student(String name, int age){
		this.name = name;
		this.age = age;
	}
	public String name;
	public int age;
	public int compareTo(Student o) {
		return name.compareTo(o.name);
	}	
}

Java中的String类实现了Comparable方法，“a”.compareTo("b")的值是-1；"b".compareTo("a")的值是1。

Student类实现了Comparable方法，就是按照name的顺序来进行排序。测试一下：

public class ComparableAndComparator {
	
	public static void main(String[] args){
		List<Student> list = new ArrayList<Student>();
		list.add(new Student("abc", 10));
		list.add(new Student("Abd", 10));
		for(Student s : list)
			System.out.println(s.name);
		Collections.sort(list);
		for(Student s : list)
			System.out.println(s.name);
	}
	
}

输出结果是：

abc
Abd
Abd
abc

Collections.sort(list)是按照list中的object所实现的Comparable来进行升序排列的，而"abc">"Abd"，因为a的ASCII码值是97，而A的ASCII码值是65，所以经过排序之后就是上述的结果了。

如果我现在在按照名字排序时忽略大小写应该怎么写呢？

2、Comparator接口

因为Student类已经实现了Comparable 接口按照name来进行排序，一种方法是修改Student中的compareTo方法实现这个需求。显然这种方式是不合理的呢，如果下次需要按照age来排序呢？所以正确的做法是实现Comparator接口

	public static void main(String[] args){
		List<Student> list = new ArrayList<Student>();
		list.add(new Student("abc", 10));
		list.add(new Student("Abd", 10));
		for(Student s : list)
			System.out.println(s.name);
		Collections.sort(list, new Comparator<Student>() {

			public int compare(Student o1, Student o2) {
				// TODO Auto-generated method stub
				return o1.name.toLowerCase().compareTo(o2.name.toLowerCase());
			}
		});
		for(Student s : list)
			System.out.println(s.name);
	}

运行结果如下：

abc
Abd
abc
Abd

只需要在用Collections进行排序时实现Comparator这个接口，然后做你想做的事情就行了~

3、其实String类也有这样一个Comparator

    /**
     * A Comparator that orders <code>String</code> objects as by
     * <code>compareToIgnoreCase</code>. This comparator is serializable.
     * <p>
     * Note that this Comparator does <em>not</em> take locale into account,
     * and will result in an unsatisfactory ordering for certain locales.
     * The java.text package provides <em>Collators</em> to allow
     * locale-sensitive ordering.
     *
     * @see     java.text.Collator#compare(String, String)
     * @since   1.2
     */
    public static final Comparator<String> CASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();
    private static class CaseInsensitiveComparator
                         implements Comparator<String>, java.io.Serializable {
	// use serialVersionUID from JDK 1.2.2 for interoperability
	private static final long serialVersionUID = 8575799808933029326L;

        public int compare(String s1, String s2) {
            int n1=s1.length(), n2=s2.length();
            for (int i1=0, i2=0; i1<n1 && i2<n2; i1++, i2++) {
                char c1 = s1.charAt(i1);
                char c2 = s2.charAt(i2);
                if (c1 != c2) {
                    c1 = Character.toUpperCase(c1);
                    c2 = Character.toUpperCase(c2);
                    if (c1 != c2) {
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }
    }

所以2中的程序可以改写为如下：

	public static void main(String[] args){
		List<Student> list = new ArrayList<Student>();
		list.add(new Student("abc", 10));
		list.add(new Student("Abd", 10));
		for(Student s : list)
			System.out.println(s.name);
		Collections.sort(list, new Comparator<Student>() {

			public int compare(Student o1, Student o2) {
				// TODO Auto-generated method stub
				return String.CASE_INSENSITIVE_ORDER.compare(o1.name, o2.name);
			}
		});
		for(Student s : list)
			System.out.println(s.name);
	}

String类中的CASE_INSENSITIVE_ORDER比直接用toUpperCase再进行比较效率会高一些