关于Comparator接口和Comparable接口的对比（实例展示）

我们首先来看看API上是如何解释的：

• Comparable接口

该接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法 。Collections.sort （和Arrays.sort ）可以自动对实现此接口的对象进行列表（和数组）排序。 实现该接口的对象，可以使用如在键sorted map或作为在元件sorted set ，而不需要指定一个comparator 。

int compareTo(T o)将此对象与指定的对象进行比较以进行排序。 返回一个负整数，零或正整数，因为该对象小于，等于或大于指定对象。

• Comparator接口

比较功能，对一些对象的集合施加了一个整体排序 。 可以将比较器传递给排序方法（如Collections.sort或Arrays.sort ），以便对排序顺序进行精确控制。与Comparable不同，比较器可以可选地允许比较空参数，同时保持对等价关系的要求。

• 来看具体实例

package HomeWork0411;

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

//实现Comparable接口，重写compareTo( )方法
class SortDemo implements Comparable<SortDemo>
{
    //首先封装两个属性
    private int age;
    private String name;
    
    public SortDemo(int age, String name)
    {
        super();
        this.age = age;
        this.name = name;
    }

    public SortDemo()
    {
        super();
        // TODO Auto-generated constructor stub
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

     //按照年龄升序排列（也可以进行降序排列 ）
    @Override 
    public int compareTo(SortDemo o)
    {
        // TODO Auto-generated method stub
        return  age - o.getAge();
    }
    
    /*
     *  Comparable接口中实现compareTo方法。jdk中的默认排序都是通过判断此接口实现，通过该接口的compareTo方法返回值比较大小排序。
     *  如Collections.Sort，及TreeMap中的排序都是默认通过compareTo的返回值进行排序。
     *  Comparable被称为内比较器。
     *  compareTo方法的返回值是int，有三种情况： 
     *  1、比较者大于被比较者（也就是compareTo方法里面的对象），那么返回正整数 
     *  2、比较者等于被比较者，那么返回0 
     *  3、比较者小于被比较者，那么返回负整数
     */
}

public class ComparableDemo
{
    /**
     * 实现升序和降序是因为比较者和被比较者的前后关系决定的
     * 实在闹不明白，那就可以把两种前后关系试着来一遍输出  看结果是否需要调整
     */
    public static void main(String[] args)
    {
         //创建一个ArrayList集合用来存放信息
         List<SortDemo> demo = new ArrayList<SortDemo>( );
         demo.add(new SortDemo(23,"adf"));
         demo.add(new SortDemo(24,"adf"));
         demo.add(new SortDemo(32,"adf"));
         demo.add(new SortDemo(25,"adf"));
         demo.add(new SortDemo(83,"adf"));
         demo.add(new SortDemo(63,"adf"));
         demo.add(new SortDemo(90,"adf"));
         demo.add(new SortDemo(23,"adf"));
         demo.add(new SortDemo(23,"adf"));
         
         System.out.println("未排序=======");
         printList(demo.iterator());
         
         //实现comparable 自排序  内部排序
         System.out.println("实现comparable 自排序  内部排序：");
         Collections.sort(demo);
         printList(demo.iterator());
         
         //实现comparator外部排序
         Comparator<SortDemo> camtor = new Comparator<SortDemo>()
         {
             /*
              *  Comparator接口有一个compare方法，若想通过Comparator接口排序， 则必须实现该
              * 类的compare方法，排序的时候，通过该方法的返回值进行排序。 利用Comparator接
              * 口排序，不需要待排序的类实现该接口，而是定义一个全新的 比较器类进行比较（具
              * 体比较规则，由用户根据具体场景定义）。
              *  Comparator常被称为外比较器。 
              * compare方法返回值和Comparable接口一样是int，有三种情况： 
              *  1、o1大于o2，返回正整数 
              *  2、o1等于o2，返回0 
              *  3、o1小于o2，返回负整数
              */

            @Override//按照年龄降序排列
            public int compare(SortDemo o1, SortDemo o2)
            {
                // TODO Auto-generated method stub
                return o2.getAge() - o1.getAge();
            }
         
         };//注意这里有个分号，因为内部是对外比较器的compare（）方法的重写
         
         System.out.println("实现comparator 外部排序：");
         Collections.sort(demo,camtor);
         printList(demo.iterator());
    }

    //用於遍历输出的方法   （又学到一招 ）
    public  static void printList(Iterator<SortDemo> iterator)
    {
        while (iterator.hasNext())
        {
            SortDemo ad = iterator.next();
            System.out.println("Age:" + ad.getAge() + "\t" + "Name:" + ad.getName());
        }
        System.out.println("=====================");
    }

}

最终的输出结果是：