Comparable接口以及Comparator接口

1、Comparable接口

这个接口也称为内比较器，这个接口支持自比较，其定义如下：

public interface Comparable<T>
     {
        int compareTo（T other);//接口的中方法自动属于public方法
     }

使用实例：

public class Employee implements Comparable<Employee>{

    private String name;
    private double salary;
    private int id;

    public Employee(String name,double salary)
    {
        this.name=name;
        this.salary=salary;
        Random ID=new Random();
        id=ID.nextInt(10000000);
    }


    public String getName() {
        return name;
    }


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


    public double getSalary() {
        return salary;
    }


    public void setSalary(double salary) {
        this.salary = salary;
    }


    public int getId() {
        return id;
    }


    public void setId(int id) {
        this.id = id;
    }

    @Override
    public int compareTo(Employee o) {
        // TODO Auto-generated method stub
        if(salary<o.salary)
            return -1;
        if(salary>o.salary)
            return 1;
        return 0;
    }

}

public class EmployeeSortTest {
    public static void main(String[] args)
    {
        Employee[] staff=new Employee[3];
        staff[0]=new Employee("Jack",10000);
        staff[1]=new Employee("Vivien",120000);
        staff[2]=new Employee("Tony",9000);
        Arrays.sort(staff);
        for(Employee e:staff)
            System.out.println(e.getName()+":"+e.getSsalary());
    }
}

输出：

Tony:9000.0

Jack:10000.0

Vivien:120000.0

2、Comparator接口以及与Comparable接口的区别

（1）Comparable接口是在java.lang包中，comparator是在java.util包中，comparable接口是嵌在要比较的类中（内比较器），但是后者是单独实现一个类（外比较器）。==Comparator 是策略模式（strategy designpattern），更加低耦合，就是不改变要比较的对象自身，而用一个策略对象（strategy object）来改变它的行为。==

（2）Comparator定义了俩个方法，分别是 int compare(T o1, T o2)和 boolean equals(Object obj)，
用于比较两个Comparator是否相等

使用过程包括数组使用sort排序时使用comparator比较器以及集合使用comparator对元素排序

单独的比较类：

public class NumComparator implements Comparator<Employee>{

    @Override
    public int compare(Employee left, Employee right) {
        // TODO Auto-generated method stub
        return (int) (left.getSalary()-right.getSalary());
    }
}

数组使用comparator：

CollectionNine(){
        NumComparator comparator=new NumComparator();
        Employee[] em={new Employee("Cato",400),new Employee("Plato",100),
                new Employee("Zeno",200),new Employee("Archimedes",500)};
        Arrays.sort(em, comparator);
        for(Employee e:em)
            System.out.println(e.getName()+":"+e.getSalary());
        }
    } 

输出：

Plato:100.0

Zeno:200.0

Cato:400.0

Archimedes:500.0

集合使用comparator

public class CollectionNine{
    public static void main(String[] args) {
        new CollectionNine();
    }
    CollectionNine(){
        NumComparator comparator=new NumComparator();
        Set<Employee> set=new TreeSet<Employee>(comparator);
        set.add(new Employee("Agamemnon",300)); 
        set.add(new Employee("Cato",400)); 
        set.add(new Employee("Plato",100)); 
        set.add(new Employee("Zeno",200)); 
        set.add(new Employee("Archimedes",500)); 
        for(Employee tag : set) 
            System.out.println(tag.getName()+":"+tag.getSalary()); 
 }

输出：

Plato:100.0

Zeno:200.0

Agamemnon:300.0

Cato:400.0

Archimedes:500.0

当然集合也可以这样用：

CollectionNine(){
        NumComparator comparator=new NumComparator();
        List<Employee> list=new ArrayList<Employee>();
        list.add(new Employee("Agamemnon",300)); 
        list.add(new Employee("Cato",400)); 
        list.add(new Employee("Plato",100)); 
        list.add(new Employee("Zeno",200)); 
        list.add(new Employee("Archimedes",500)); 
//        Employee[] em=(Employee[]) set.toArray();
        Collections.sort(list, comparator);
        for(Employee tag : list) 
            System.out.println(tag.getName()+":"+tag.getSalary());

输出：
Plato:100.0
Zeno:200.0
Agamemnon:300.0
Cato:400.0
Archimedes:500.0