Comparable和Comparator接口

Java中有2个用于比较的接口，[b]Comparable[/b]和[b]Comparator[/b]，
Comparable接口有一个compareTo方法，Comparator接口有compare和equals方法，
因为Object类有equals方法，所以实现Comparator接口的类，可以不用实现这个方法

[b]Comparable[/b]代表这个类是可以被比较的（比较大小有意义，且比较规则与人们思维相同），
比如String Integer，直接调用bean1.compareTo(bean2)

[b]Comparator[/b]是一个比较器，用于不是经常被比较的类，主要用在排序方法，
Arrays.sort(T[] a, Comparator<? super T> c)
Collections.sort(List<T> list, Comparator<? super T> c)，
使用时，建立匿名类实现

可以观察Collections工具类的两个sort方法

//可以比较的类（实现了Comparable接口），直接调用sort方法即可
public static <T extends Comparable<? super T>> void sort(List<T> list)

//不能比较的类，sort时候，请自己实现Comparator接口
public static <T> void sort(List<T> list, Comparator<? super T> c) 

//这两个方法还说明了一点，定义泛型标记在方法上应优先定义在类上，因为这样可以static，直接调用泛型方法，
//而泛型类必须实例化后才能使用，Arrays，Collections这些工具类，都没有将泛型定义在类上。

下面是一个例子，

import java.util.*;
public class Compare {
	public static void main(String[] args) {
		System.out.println(
				new ComparableClass(2).compareTo(new ComparableClass(4)));
		UnComparableClass[] c2s = { new UnComparableClass(4),
				new UnComparableClass(2), new UnComparableClass(5) };
		System.out.println("before sort " + Arrays.toString(c2s));
		Arrays.sort(c2s, new Comparator<UnComparableClass>() {
			public int compare(UnComparableClass o1, UnComparableClass o2) {
				return o1.getI() - o2.getI();
			}
		});
		System.out.println("after sort " + Arrays.toString(c2s));
	}
}
class UnComparableClass {
	private int i;
	public UnComparableClass(int i) {
		this.i = i;
	}
	public int getI() {
		return i;
	}
	@Override
	public String toString() {
		return String.valueOf(i);
	}
}
class ComparableClass implements Comparable<ComparableClass> {
	private int i;
	public ComparableClass(int i) {
		this.i = i;
	}
	// 这里很有意思，anotherC1的i属性，是private的，但是也可以直接使用
	public int compareTo(ComparableClass anotherC1) {
		return this.i - anotherC1.i;
	}
}
//Output:
//-2
//before sort [4, 2, 5]
//after sort [2, 4, 5]