Comparable与Comparator接口的区别

Comparable与Comparator接口在数据排序中经常用到，最近差点把他们用混淆了，以下是自己编写的分析它们区别的测试代码。

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

/**
 * 主要区别：
 * 假设有人给你一个并没有实现Comparable的类，或者你的类实现了Comparable，
 * 但是你不喜欢它的实现方式，你需要另外一种不同的比较方法，要解决这个问题，可以创建
 * 一个实现了Comparator接口的单独的类。Comparable实现一般用于类的自比较 ，
 * 而比较器Comparator实现不仅可以自比较，而且还可以用于没有继承关系的不同类型对象的比较。
 * 
 * @author LeiMin
 */
public class Comptype {

    /**
     * @param args
     */
    public static void main(String[] args) {
        List<Object> list = new ArrayList<Object>();
        A a = new A(6);
        A a1 = new A(12);
        A a2 = new A(8);
        B b = new B(14);
        B b1 = new B(11);
        list.add(a);
        list.add(a1);
        list.add(a2);
        list.add(b);
        list.add(b1);
        System.out.println(list);
        //使用自定义的比较器排序
        Collections.sort(list, new Comparator() {

            @Override
            public int compare(Object o1, Object o2) {
                if (o1.getClass() == o2.getClass()) {
                    if (o1 instanceof B)
                        return ((B) o1).getB() - ((B) o2).getB();
                    else if (o1 instanceof A)
                        return ((A) o1).getA() - ((A) o2).getA();
                } else {
                    if (o1 instanceof A && o2 instanceof B)
                        return ((A) o1).getA() - ((B) o2).getB();
                    else if (o1 instanceof B && o2 instanceof A)
                        return ((B) o1).getB() - ((A) o2).getA();
                }
                return 0;
            }

        });
        System.out.println(list);
        List<A> list1 = new ArrayList<A>();
        list1.add(a);
        list1.add(a1);
        list1.add(a2);
        list1.add(b);
        list1.add(b1);
        System.out.println(list1);
        //使用类自带自然排序方法排序
        Collections.sort(list1);
        System.out.println(list1);
        List<Object> list2 = new ArrayList<Object>();
        C c = new C(20);
        list2.add(a);
        list2.add(c);
        //不同类型对象排序比较不能使用Comparable实现
        //        Collections.sort(list2); // compile error 
        //        Comparable[] c = new Comparable[] { a, a1, a2, b, b1 };
        //        print(c);
        //        insertionSort(c);
        //        print(c);

    }

    /*
     * public static void print(Comparable[] data) { if (data != null &&
     * data.length > 0) { StringBuilder sb = new StringBuilder("["); for (int i
     * = 0; i < data.length; i++) sb.append(data[i]).append(", ");
     * sb.deleteCharAt(sb.length() - 2).deleteCharAt(sb.length() -
     * 1).append("]"); System.out.println(sb); } } public static void
     * insertionSort(Comparable[] data) { for (int index = 1; index <
     * data.length; index++) { Comparable key = data[index]; int position =
     * index; //把较大值右移一位 while (position > 0 && data[position -
     * 1].compareTo(key) > 0) { data[position] = data[position - 1]; position--;
     * } data[position] = key; } }
     */
}

class A implements Comparable<A> {

    /**
     * 
     */
    public A() {
        super();
    }

    private int a;

    /**
     * @return the a
     */
    public int getA() {
        return a;
    }

    /**
     * @param a the a to set
     */
    public void setA(int a) {
        this.a = a;
    }

    /**
     * @param a
     */
    public A(int a) {
        super();
        this.a = a;
    }

    @Override
    public String toString() {
        return "A[a=" + a + "]";
    }

    @Override
    public int compareTo(A o) {
        if (o instanceof B)
            return a < ((B) o).getB() ? -1 : (a == ((B) o).getB() ? 0 : 1);
        else if (o instanceof A)
            return a < ((A) o).getA() ? -1 : (a == ((A) o).getA() ? 0 : 1);
        else
            return 0;
    }
}

class B extends A {

    private int b;

    /**
     * @return the b
     */
    public int getB() {
        return b;
    }

    /**
     * @param b the b to set
     */
    public void setB(int b) {
        this.b = b;
    }

    /**
     * @param b
     */
    public B(int b) {
        this.b = b;
    }

    @Override
    public String toString() {
        return "B[b=" + b + "]";
    }

    @Override
    public int compareTo(A o) {
        if (o instanceof B)
            return b < ((B) o).getB() ? -1 : (b == ((B) o).getB() ? 0 : 1);
        else if (o instanceof A)
            return b < ((A) o).getA() ? -1 : (b == ((A) o).getA() ? 0 : 1);
        else
            return 0;
    }

}

class C implements Comparable<Object> {

    /**
     * @return the c
     */
    public int getC() {
        return c;
    }

    /**
     * @param c
     */
    public C(int c) {
        super();
        this.c = c;
    }

    /**
     * @param c the c to set
     */
    public void setC(int c) {
        this.c = c;
    }

    private int c;

    @Override
    public int compareTo(Object o) {
        if (o instanceof A)
            return c - ((A) o).getA();
        else if (o instanceof C)
            return c - ((C) o).getC();
        return 0;
    }

}