疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java排序之Comparable接口和Comparator接口的比较和应用示例


 

 
一、其实很简单,单从字面理解就基本明白
1. Comparable:“可比较的”,(欲参与比较的对象对应的元素类需实现Comparable接口)
使用这种策略来比较时,两个对象(这里两个对象是指一个类的两个不同实例)本身必须是“可比较的”,比较的标准由对象所在的类来定义,这种可比较的能力是对象本身固有的,因此不需要第三方参与就可以完成比较。要使得两个对象本身是可比较的,那么对象所在的类必须实现Comparable接口才可以。其compareTo()方法只要一个参数,因为这里只有“你”“我”的关系,没有第三方。
比如,两个人要比较身高,分辨高矮是人类固有的能力,两个人只要站到一起就能分出谁高谁矮。
2. Comparator:“比较器”
使用这种策略来比较时,如何进行比较和两个对象本身无关,而是由第三者(即比较器)来完成的。第三方比较器类需要另外专门设计:只要实现Comparator接口,任何一个类(对象)都可能成为一个“比较器”,但比较器并不是比较自己的实例,而是比较其它类的两个不同对象,比较器在这里充当“仲裁者”的角色,这也就是为什么compare()方法需要两个参数。
比如,两个人要比较谁智商更高,靠他们自身无法进行,这时要借助一个比较器(比如,智商测试题)。
注: Comparable和Comparator这两个接口和集合接口(Collection)本身无关,但通常和集合内的元素有关,因为集合的排序要用到这两个排序接口中的方法(二选其一)。一个类的多个实例要想
 
实现排序,必须实现Comparable,或者提供相应的Comparator才能使用Collections.sort()进行排序。
这里我们需要专门说明一下:java.util.Collections,是不属于java的集合框架的,它是一个集合的工具类,它包含专门操作集合(Collection)的静态方法,如排序、拷贝、匹配查找等等,比如我们常用它的排序方法:Collections.sort(List), Collections.sort(List, Comparator)。
二、代码示例
1. 假如你维护着一个简单的员工数据库,每个员工是一个Employee类的实例。
Employee类可定义为:
[java] view plain copy
public class Employee {   
    private String num;  
    private String name;  
    private int age;  
    private int salary;   
    public Employee(String num, String name) {  
        this.num = num;  
        this.name = name;  
    }     
    public void setName(String newNum) {  
        num = newNum;  
    }  
  
    public void setAge(int newAge) {  
        age = newAge;  
    }  
    public void setSalary(int newSalary) {  
        salary = newSalary;  
    }  
    public String getNum() {  
        return num;  
    }  
    public String getName() {  
        return name;  
    }  
    public int getAge() {  
        return age;  
    }  
    public int getSalary() {  
        return salary;  
    }  
    public String toString() {  
        StringBuffer sb = new StringBuffer();  
        sb.append("Employee Information:");  
        sb.append(" ");  
        sb.append("Number:");  
        sb.append(getNum());  
        sb.append(" ");  
        sb.append("Name:");  
        sb.append(getName());  
        sb.append(" ");  
        sb.append("Age:");  
        sb.append(getAge());  
        sb.append(" ");  
        sb.append("Salary:");  
        sb.append(getSalary());  
        sb.append(" ");  
        return sb.toString();  
    }  
}  
EmployeeDatabase类创建Employee类的实例,并把它们存入集合:
[java] view plain copy
import java.util.*;  
  
public class EmployeeDatabase {  
      
    public static void main(String[] args) {  
          
        List<Employee> allEmployees = new ArrayList<Employee>();  
          
        Employee employee1 = new Employee("AAA", "Barack Omaba");  
        employee1.setAge(50);  
        employee1.setSalary(9999);  
        allEmployees.add(employee1);  
          
        Employee employee2 = new Employee("BBB", "George Bush");  
        employee2.setAge(60);  
        employee2.setSalary(5999);  
        allEmployees.add(employee2);  
          
        System.out.println(allEmployees);  
  
    }  
  
}  
2. 现在,你需要检索所有员工,并让他们按一定顺序显示(比如按年龄递增),这时需要用到Collections.sort()方法。
Collections.sort()有两种策略:一种是让集合中元素所属类本身实现Comparable接口,另一种是使用用户另外提供的比较器(即Comparator)。
2.1 使用第一种策略时,必须修改元素类的定义,让它实现Comparable接口,因此,你必须把Employee类修改为:
[java] view plain copy
public class Employee implements Comparable<Employee> {  
      
    public int compareTo(Employee another) {  
        return getAge() - another.getAge();  
    }  
      
    // 其余部分不变  
  
}  
说明一下,因为compareTo()方法约定:本对象大于另一个对象时,返回大于0的整数,小于时返回小于0的整数,等于时返回0。所以,可以直接返回两者年龄的差,来实现按年龄比较。这样就可以
 
在main()方法中使用Collections.sort(allEmployees);来对员工按年龄排序了。
但是,这种排序是非常不灵活的:
第一,需要修改集合元素类Employee,而很多情况下,我们没有办法修改公共的类。
第二,没有办法实现多种方式排序,如按编号,按姓名,按薪水等等。
2.2 这时需要使用另一种策略,创建一个比较器类,其需要实现Comparator接口。Comparator使用其compare()方法返回的整数来比较两个对象,规则和compareTo()一样。
如同样实现年龄比较,使用Comparator时,无需修改Employee类,可以在排序的时候定义相应的比较器。使用Collections.sort()方法的另一个版本:
[java] view plain copy
Collections.sort(allEmployees, new Comparator<Employee>() {  
    public int compare(Employee one, Employee another) {  
        return one.getAge() - another.getAge();  
    }  
});  
这里代码使用了匿名内部类,实际上相当于先定义一个比较器类,如:
[java] view plain copy
class EmployeeComparator implements Comparator<Employee> {  
      
    public int compare(Employee one, Employee another) {  
        return one.getAge() - another.getAge();  
    }  
      
}  
再使用:
[java] view plain copy
Collections.sort(allEmployees, new EmployeeComparator());  
可以看到,比较器完全独立于元素类Employee,因此可以非常方便地修改排序规则。
你还可以定义一系列比较器,供排序时选择使用,如:
[java] view plain copy
// 按薪水升序  
class EmployeeSalaryAscendingComparator implements Comparator<Employee> {  
      
    public int compare(Employee one, Employee another) {  
        return one.getSalary() - another.getSalary();  
    }  
      
}  
  
// 按薪水降序  
class EmployeeSalaryDescendingComparator implements Comparator<Employee> {  
      
    public int compare(Employee one, Employee another) {  
        return another.getSalary() - one.getSalary();  
    }  
      
}  
相应的使用方法如:
[java] view plain copy
Collections.sort(allEmployees, new EmployeeSalaryAscendingComparator());  
Collections.sort(allEmployees, new EmployeeSalaryDescendingComparator());  
等等....
使用Comparator时,元素类无需实现Comparable,因此我们保持最初版本的Employee,但实际应用
 
中,可以用Comparable的compareTo()方法来定义默认排序方式,用Comparator定义其他排序方式。
三、总结-Camparable接口和Comparator接口的比较
1. Camparable的使用方式是:在欲比较的类内部定义实现compareTo()方法,然后再使用Collections. sort()来实现排序,而Comparator是在欲比较的类外部实现的排序。所以,如想实现排序,就需要在在类内实现Comparable接口的方法compareTo() 或类外定义实现Comparator接口的方法compare()。
Comparable是一个对象本身就已经支持自比较所需要实现的接口(如String ,Integer自己就可以完成比较大小操作),而Comparator是一个专用的比较器,当这个对象不支持自比较或者自比较函数不能满足你的要求时,你可以写一个比较器来完成两个对象之间大小的比较。
2.一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的,这个类对象组成的集合就可以直接使用sort()方法排序。一般我们写的bean都要都要实现这一接口,这也是标准
 
javabean的规范。
3.Comparator可以看成一种算法的实现,将算法和数据分离,Comparator也可以在下面两种场景下使用:
3.1 类的设计师没有考虑到比较问题而没有实现Camparable接口,我们可以通过Comparator来实现排序而不必改变类本身。比如,你使用了一个第三方的类,但这个第三方类么有实现Camparable接口,而你又不能改它的代码,另外,类一旦写好后是不允许修改的,但 可以拓展,这时候只能使用Comparator来实现排序。
3.2 可以使用多种排序标准,比如升序、降序等。
比如,实现Comparable只能定义一种比较方法即compareTo(),但是有时候会对一个集合进行不同的排序方法,此时就可以提供别各种各样的Comparator来对集合排序,而对于要排序的元素不需要更改,所以我觉得Comparator提供了更多的灵活性。