comparable和comparator

java中提供了2中比较方式。第一种是实现java.util.Comparable接口。

public class CompType implements Comparable<Object> {
    int i,j;
    public CompType(int a,int b){
        i=a;
        j=b;
    }
    public String toString(){
        return "[i="+i+",j="+j+"]";
    }
    @Override
    public int compareTo(Object o) {
        int rvi=((CompType)o).i;
        return (i<rvi?-1:(i==rvi?0:1));
    }
    private static Random random=new Random();
    public static Generator generator(){
        return new Generator(){
            public Object next(){
                return new CompType(random.nextInt(100),random.nextInt(100));
            }
        };
    }
    public static void main(String[] args) {
        CompType[] ct=new CompType[10];
        Arrays2.fill(ct, generator());
        System.out.println("before sorting ct:"+Arrays.asList(ct));
        Arrays.sort(ct);
        System.out.println("after sorting ct:"+Arrays.asList(ct));
    }
}

第二种是使用比较器java.util.Comparator.这里使用了策略设计模式。通过策略模式，将会发生变化的代码包装在类中（策略对象），将策略对象交给保持不变的代码，后者使用

此策略实现它的算法。在这里，可以为不同的比较方式生成不同的对象，将他们用在同样的排序程序中。

public class AlphabeticComparator implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {
        return o1.toString().toLowerCase().compareTo(o2.toString().toLowerCase());
    }
}
public class AlphabeticSorting {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        String[] sa=new String[10];
        Arrays2.fill(sa, new Arrays2.RandomStringGenerator(5));
        System.out.println("before sorting sa:"+Arrays.asList(sa));
        Arrays.sort(sa,new AlphabeticComparator());
        System.out.println("after sorting sa:"+Arrays.asList(sa));
    }
}

public class Reverse {
public static void main(String[] args) {
String[] a={"a","b","c"};
System.out.println("before sorting a:"+Arrays.asList(a));
Arrays.sort(a,Collections.reverseOrder());
System.out.println("after reverse sorting a:"+Arrays.asList(a));

}
}