Java中的排序Comparable接口和Comparator接口

普通的类要实现排序，必须实现Comparable接口，并重写CompareTo()方法。
package test;
public class Field implements Comparable<Field> {
    private String name;
    private int age;
    public Field() {
    }
    public Field(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

@Override
    public int compareTo(Field o) {
        // 先按age排序
        if (this.age > o.getAge()) {
            return (this.age - o.getAge());
        }
        if (this.age < o.getAge()) {
            return (this.age - o.getAge());
        }
        // 按name排序
        if (this.name.compareTo(o.getName()) > 0) {
            return 1;
        }
        if (this.name.compareTo(o.getName()) < 0) {
            return -1;
        }
        return 0;
    }
}
package test;

import Java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Test2 {
    public static void main(String[] args) {
        Field f1 = new Field("tony", 11);
        Field f2 = new Field("jack", 11);
        Field f3 = new Field("tom", 11);
        Field f4 = new Field("jason", 44);
        List<Field> list = new ArrayList<Field>();
        list.add(f1);
        list.add(f3);
        list.add(f4);
        list.add(f2);
        Collections.sort(list);
        for (Field o : list) {
            System.out.println(o.getAge() + "-->" + o.getName());
        }
    }
}

Comparator

package com.tianjf; 
       
    import java.util.Arrays; 
    import java.util.Comparator; 
       
    public class MyComparator implements Comparator<Object> { 
       
        @Override 
        public int compare(Object o1, Object o2) { 
            return toInt(o1) - toInt(o2); 
        } 
       
        private int toInt(Object o) { 
            String str = (String) o; 
            str = str.replaceAll("一", "1"); 
            str = str.replaceAll("二", "2"); 
            str = str.replaceAll("三", "3"); 
            return Integer.parseInt(str); 
        }

/**
        * 测试方法
        */ 
     

public static void main(String[] args) { 
            String[] array = new String[] { "一", "三", "二" }; 
            Arrays.sort(array, new MyComparator()); 
            for (int i = 0; i < array.length; i++) { 
                System.out.println(array[i]); 
            } 
        } 
    }

相信在看了代码以后就应该明白些了吧，现在再简单说一下Comparable接口和Comparator接口之间的区别（纯属个人想法）。我觉得Comparable接口的最大作用就在于定义一个自定义的类的比较规则，因为CompareTo方法只有一个参数，另一个参数是this，也就是这个类本身，所以我们可以把它看成是在类的内部定义比较规则，相当于Java开发人员在写String类的时候就应该让它实现Comparable接口。然而，compare方法有两个参数，这两个参数可以是任意类型的，可以是已经定义过的String类型，也可以是自定义的类型。如果是已经定义过的类型，compare方法可以对它的规则进行重新定义，如果是自定义的类型，可以新定义一个规则。
 
总结：
comparable是支持自比较，而后者是支持外部比较；