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是支持自比较，而后者是支持外部比较； 
comparable&   Comparator    都是用来实现集合中的排序的，只是Comparable是在集合内部定义的方法实现的排序，Comparator是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义Comparator接口的方法compare()或在集合内实现Comparable接口的方法compareTo()。 
Comparable是一个对象本身就已经支持自比较所需要实现的接口（如String    Integer自己就可以完成比较大小操作）   
    
   而Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。

    也就是说当你需要对一个自定义的类的一个数组或者集合进行比较的时候可以实现Comparable接口，当你需要对一个已有的类的数组或者集合进行比较的时候就一定要实现Comparator接口。另外，这两个接口是支持泛型的，所以我们应该在实现接口的同时定义比较类型。

本文出自 “breezewindlw” 博客，请务必保留此出处http://breezewindlw.blog.51cto.com/6504579/1616530

原文：http://breezewindlw.blog.51cto.com/6504579/1616530