Comparable 与 Comparator

Comparable 与 Comparator异同之处

1. 都是 java 的一个接口，并且都是用来对自定义的 class 进行比较大小的。
2. Comparable是通用的接口，用户可以实现它来完成自己特定的比较，而Comparator可以看成一种算法的实现,在容器集合 collection 需要比较功能的时候，来指定这个比较器，这可以看出一种设计模式，将算法和数据分离。
3. Comparable 比较固定，都是和一个具体的类绑定在一起（类似“静态绑定”）；而Comparator 则比较灵活，它可以被各个需要比较功能的类使用（类似"动态绑定"）。
4. 一个实现 Comparable 接口的类，表示该类的所有对象之间是可以比较的，存在着一定的顺序性。这时候就可以用 sort 方法来排序了。
5. Comparator 接口的作业主要有两个：
   • 若某个程序猿在没有考虑 compare 问题时没有实现 Comparable 接口，恰又需要对象比较时候，就可以选着用 Comparator 接口来实现比较算法的排序。
   • 可以进行多种方式排序，例如：升序、降序、Id排序、成绩排序等等

Comparable的实现

• 以下代码以一个员工类利用 Comparable 接口实现每员工的排序。首先是声明一个 Employee 员工类，并且实现 Comparable 接口，重写 compare 方法（本例子是通过员工工资排序的）。
• 如果有人不清楚 compare() 函数意义的，可以利用以下代码中我重写的插入排序算法来加以理解。
• 最后在主方法中声明一个 Employee 的数组，再将所实例化的员工放入数组中。最后调用Arrays.sort(staff) 进行排序,再输出显示。

import java.util.*;  
/*
* 因为要实现对Employee对象的排序，所以在Employee类中要实现Comparable接口，
* 也就是要实现comepareTo()方法
*/
class Employee  implements Comparator<Employee>  
{  
    public Employee(String n, double s)  
        {  
            name = n;  
            salary = s;  
            Random ID =  new Random();  
            id = ID.nextInt( 10000000 );  
        }  
    public int getId()  
    {  
        return id;  
    }  
    public String getName()  
    {  
        return name;  
    }  
    public double getSalary()  
    {  
        return salary;  
    }  
    
    @Override
    public int compare(Employee other1,Employee other2)  
    {  
        if (other1.salary < other2.salary) 
            return - 1 ;  
        if (other1.salary > other2.salary)  
            return 1 ;  
        return 0 ;  
    }  
    private int id;  
    private String name;  
    private double salary;  
}
public class EmployeeSortTest {  
public static void main(String[] args) {  
        Employee[] staff =  new Employee[ 6 ];  
        staff[ 0 ] =  new Employee( "harry Hacker" , 35000 );  
        staff[ 1 ] =  new Employee( "carl cracke" , 25010 );  
        staff[ 2 ] =  new Employee( "tony Tester" , 38200 );  
        staff[ 3 ] =  new Employee( "Michale" , 23000 );
        staff[ 4 ] =  new Employee( "Cindy" , 31100 );
        staff[ 5 ] =  new Employee( "Yancy" , 32000 );
        Arrays.sort(staff); //sort方法可以实现对对象数组排序，但是必须实现 Comparable接口      
        //insertSort(staff);//插入排序算法
        for (Employee e: staff) {
            if (e != null) 
                 System.out.println( "id=" +e.getId()+ "  name=" +e.getName()+  
                         ".salary=" +e.getSalary());
        }  
    }
    //重写排序算法，利用插入排序。一般使用的 Arrays.sort() 利用的是快速排序算法
    /*public static <AnyType extends Comparable<? super AnyType>>
        AnyType[] insertSort (AnyType arr[]) {//一样实现Comparable接口
        int i,j;
        AnyType temp;
        for ( i = 1; i < arr.length; i++) {
            if(arr[i] != null){
                temp = arr[i];          //主要原理就在于compareTo的使用
                for ( j = i; j>0 && temp.compareTo(arr[j-1])< 0; j--) 
                    arr[j] = arr[j-1];
                arr[j] = temp;
            }
        }
        return arr;
    }*/
}  

Comparator的实现

• 一下 Comparator 相关的代码 与 Comparable 接口不同之处在于实现 Compare 方法是在 Employee 类的外部，并且可以进行多种排序方式。
• 主方法中调用排序函数也不相同 Array.sort(staff,new sortById)。

import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;

public class CompartorStudy {

    public static void main(String[] args) {
        Employee1[] staff =  new Employee1[ 6 ];  
        staff[ 0 ] =  new Employee1( "harry Hacker" , 35000 );  
        staff[ 1 ] =  new Employee1( "carl cracke" , 25010 );  
        staff[ 2 ] =  new Employee1( "tony Tester" , 38200 );  
        staff[ 3 ] =  new Employee1( "Michale" , 23000 );
        staff[ 4 ] =  new Employee1( "Cindy" , 31100 );
        staff[ 5 ] =  new Employee1( "Yancy" , 32000 );
        
        Arrays.sort(staff,new sortById());
        for (Employee1 e : staff) {
            System.out.println( "id=" +e.getId()+ "  name=" +e.getName()+  
                     ".salary=" +e.getSalary());
        }
        Arrays.sort(staff,new sortBySalary());
        for (Employee1 e : staff) {
            System.out.println( "id=" +e.getId()+ "  name=" +e.getName()+  
                     ".salary=" +e.getSalary());
        }
    }

}

class Employee1{
    public Employee1(String name,double salary) {
        this.name = name;
        this.salary = salary;
        Random ID = new Random();
        id = ID.nextInt( 1000000 );
    }
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    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 void raiseSalary( double byPercent) {  
        double raise  = salary *byPercent/ 100 ;  
        salary+=raise;  
    } 
    private int id;
    private String name;
    private double salary;
}

class sortById implements Comparator<Employee1>{

    @Override
    public int compare(Employee1 o1, Employee1 o2) {
        return o1.getId() - o2.getId();
    }
}
class sortBySalary implements Comparator<Employee1>{

    @Override
    public int compare(Employee1 o1, Employee1 o2) {
        if (o1.getSalary() > o2.getSalary()) {
            return -1;
        }else if (o1.getSalary() < o2.getSalary()) {
            return 1;
        }else 
            return 0;
    }
}