Java中两种比较器的实现

先举例说明: 
例一:如果要对一组数字进行排序,可以写一个排序算法实现。 
例如: 
1 4 6 5 3 8 
排序后: 
1 3 4 5 6 8 

例二:如果要对字母进行排序,则可以通过26个字母的自然顺序进行排序。 
例如: 
a f b e d c 
排序后: 
a b c d e f 

但是工作中,有时不仅仅是这么简答的需求。例如要对一个员工进行排序,员工有员工编号,有薪资等。这时就需要用Java中的比较器来实现了。 

Java 中提供了两种方式来实现比较: 
1、java.util.Comparator<T> 接口声明了: int compare<T o1, T o2> 方法
 
  比较用来排序的两个参数: 
  1)如果o1大于o2,则返回正整数; 
  2)如果o1小于o2,则返回负整数 
  3)如果o1等于o2,则返回零 

2、java.lang.Comparable<T> 接口声明了: int compareTo(T o) 方法 
  比较此对象与执行对象的顺序。比较规则同上,即: 
  1)如果此对象大于指定对象,返回正整数 
  2)如果此对象小于指定对象,返回负整数 
  3)如果此对象等于指定对象,返回零 

下面举个简单的例子说明。 
需求:对员工进行排序,员工有员工编号和薪资。排序要求: 
1)按照员工的编号id进行排序 
2)如果员工的编号id相等,则按照员工的薪资进行比较 

上代码: 
1)先定义一个员工实体,员工实体实现了java.lang.Comparable接口,并重写compareTo(T o)方法。代码很简洁,就两个私有属性: 

Java代码   收藏代码
  1. /** 
  2.  * 员工实体 
  3.  * @author Sam 
  4.  * 
  5.  */  
  6. public class Employee implements Comparable<Employee> {  
  7.       
  8.     private int id;// 员工编号  
  9.     private double salary;// 员工薪资  
  10.       
  11.     public int getId() {  
  12.         return id;  
  13.     }  
  14.   
  15.     public void setId(int id) {  
  16.         this.id = id;  
  17.     }  
  18.   
  19.     public double getSalary() {  
  20.         return salary;  
  21.     }  
  22.   
  23.     public void setSalary(double salary) {  
  24.         this.salary = salary;  
  25.     }  
  26.       
  27.     public Employee(int id, double salary) {  
  28.         super();  
  29.         this.id = id;  
  30.         this.salary = salary;  
  31.     }  
  32.       
  33.     // 为了输出方便,重写toString方法  
  34.     @Override  
  35.     public String toString() {  
  36.         // 简单输出信息  
  37.         return "id:"+ id + ",salary=" + salary;  
  38.     }  
  39.   
  40.     // 比较此对象与指定对象的顺序  
  41.     @Override  
  42.     public int compareTo(Employee o) {  
  43.         // 比较员工编号,如果此对象的编号大于、等于、小于指定对象,则返回1、0、-1  
  44.         int result = this.id > o.id ? 1 : (this.id == o.id ? 0 : -1);  
  45.         // 如果编号相等,则比较薪资  
  46.         if (result == 0) {  
  47.             // 比较员工薪资,如果此对象的薪资大于、等于、小于指定对象,则返回1、0、-1  
  48.             result = this.salary > o.salary ? 1 : (this.salary == o.salary ? 0 : -1);  
  49.         }  
  50.         return result;  
  51.     }  
  52.   
  53. }  


2、主类(测试类):主类内部定义了一个员工比较器 

Java代码   收藏代码
  1. /** 
  2.  * 测试两种比较器 
  3.  * @author Sam 
  4.  * 
  5.  */  
  6. public class TestEmployeeCompare {  
  7.   
  8.     /** 
  9.      * @param args 
  10.      */  
  11.     public static void main(String[] args) {  
  12.           
  13.         List<Employee> employees = new ArrayList<Employee>();  
  14.         employees.add(new Employee(25000));  
  15.         employees.add(new Employee(14500));  
  16.         employees.add(new Employee(43500));  
  17.         employees.add(new Employee(53000));  
  18.         employees.add(new Employee(44000));  
  19.         // 内部比较器:要排序的对象要求实现了Comparable接口  
  20.         Collections.sort(employees);  
  21.         System.out.println("通过内部比较器实现:");  
  22.         System.out.println(employees);  
  23.           
  24.         List<Employee> employees2 = new ArrayList<Employee>();  
  25.         employees2.add(new Employee(25000));  
  26.         employees2.add(new Employee(14500));  
  27.         employees2.add(new Employee(43500));  
  28.         employees2.add(new Employee(53000));  
  29.         employees2.add(new Employee(44000));  
  30.         // 外部比较器:自定义类实现Comparator接口  
  31.         Collections.sort(employees2, new EmployeeComparable());  
  32.         System.out.println("通过外部比较器实现:");  
  33.         System.out.println(employees2);  
  34.     }  
  35.   
  36. }  
  37.   
  38. /** 
  39.  * 自定义员工比较器 
  40.  * 
  41.  */  
  42. class EmployeeComparable implements Comparator<Employee> {  
  43.   
  44.     @Override  
  45.     public int compare(Employee o1, Employee o2) {  
  46.         // 比较员工编号,如果此对象的编号大于、等于、小于指定对象,则返回1、0、-1  
  47.         int result = o1.getId() > o2.getId() ? 1 : (o1.getId() == o2.getId() ? 0 : -1);  
  48.         // 如果编号相等,则比较薪资  
  49.         if (result == 0) {  
  50.             // 比较员工薪资,如果此对象的薪资大于、等于、小于指定对象,则返回1、0、-1  
  51.             result = o1.getSalary() > o2.getSalary() ? 1 : (o1.getSalary() == o2.getSalary() ? 0 : -1);  
  52.         }  
  53.         return result;  
  54.     }  
  55.       
  56. }  



程序输出结果: 
为了让大家较全,我把结果拷贝下来,如下: 

通过内部比较器实现: 
[id:1,salary=4500.0, id:2,salary=5000.0, id:4,salary=3500.0, id:4,salary=4000.0, id:5,salary=3000.0] 
通过外部比较器实现: 
[id:1,salary=4500.0, id:2,salary=5000.0, id:4,salary=3500.0, id:4,salary=4000.0, id:5,salary=3000.0] 

结果分析: 
1)从程序输出结果中,可以很清晰的看出,两个比较器均可以实现同样的需求 
2)id都为4的员工编号中,按照薪资来进行排序了 

最后,总结一下两种比较器的区别: 
1)如果使用内部比较器,需要比较的对象必须要实现Comparable接口,并重写compareTo( 
T o)方法,否则不能直接使用Collections中的sort方法,程序会报错。因为程序不知道你要以何种方式来进行比较。 
2)使用外部比较器,需要自己写一个比较器实现Comparator接口,并实现compare(T o1, T o2)方法,根据自己的需求定义比较规则。使用外部比较器这种方式比较灵活,例如现在需求是按照员工编号和薪资进行排序,以后可能按照姓名进行排序,这时只要再写一个按照姓名规则比较的比较器就可以了。 

  • 1
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值