java比较器(Comparable和Comparator的比较)

java比较器

1.Comparable和Comparator的比较

(1)

Comparator位于包java.util下

Comparable位于包java.lang下

(2)

Comparable接口声明了compareTo(Object o)方法

Comparator 接口声明了compare(Object o1,Object o2)方法

(3)

Comparable 是在集合内部定义的方法实现的排序

Comparator 是在集合外部实现的排序所以如想实现排序，就需要在集合外定义 Comparator 接口的方法或在集合内实现 Comparable 接口的方法

2.先定义一个员工实体，员工实体实现了java.lang.Comparable接口，并重写compareTo(T o)方法。

/** 
 * 员工实体 
 * @author Sam 
 * 
 */  
public class Employee implements Comparable<Employee> {  
      
    private int id;// 员工编号  
    private double salary;// 员工薪资  
      
    public int getId() {  
        return id;  
    }  
  
    public void setId(int id) {  
        this.id = id;  
    }  
  
    public double getSalary() {  
        return salary;  
    }  
  
    public void setSalary(double salary) {  
        this.salary = salary;  
    }  
      
    public Employee(int id, double salary) {  
        super();  
        this.id = id;  
        this.salary = salary;  
    }  
      
    // 为了输出方便，重写toString方法  
    @Override  
    public String toString() {  
        // 简单输出信息  
        return "id:"+ id + ",salary=" + salary;  
    }  
  
    // 比较此对象与指定对象的顺序  
    @Override  
    public int compareTo(Employee o) {  
        // 比较员工编号，如果此对象的编号大于、等于、小于指定对象，则返回1、0、-1  
        int result = this.id > o.id ? 1 : (this.id == o.id ? 0 : -1);  
        // 如果编号相等，则比较薪资  
        if (result == 0) {  
            // 比较员工薪资，如果此对象的薪资大于、等于、小于指定对象，则返回1、0、-1  
            result = this.salary > o.salary ? 1 : (this.salary == o.salary ? 0 : -1);  
        }  
        return result;  
    }  
  
}  

3.自定以比较器

import java.util.Comparator;

/**
 * 自定义员工比较器
 * 
 */
public class EmployeeComparable implements Comparator<Employee> {

	@Override
	public int compare(Employee o1, Employee o2) {
		// 比较员工编号，如果此对象的编号大于、等于、小于指定对象，则返回1、0、-1
		int result = o1.getId() > o2.getId() ? 1 : (o1.getId() == o2.getId() ? 0 : -1);
		// 如果编号相等，则比较薪资
		if (result == 0) {
			// 比较员工薪资，如果此对象的薪资大于、等于、小于指定对象，则返回1、0、-1
			result = o1.getSalary() > o2.getSalary() ? 1 : (o1.getSalary() == o2.getSalary() ? 0 : -1);
		}
		return result;
	}
}

4.测试

/** 
	 * 测试两种比较器 
	 * @author Sam 
	 * 
	 */  
	public class TestEmployeeCompare {  
	  
	    /** 
	     * @param args 
	     */  
	    public static void main(String[] args) {  
	          
	        List<Employee> employees = new ArrayList<Employee>();  
	        employees.add(new Employee(2, 5000));  
	        employees.add(new Employee(1, 4500));  
	        employees.add(new Employee(4, 3500));  
	        employees.add(new Employee(5, 3000));  
	        employees.add(new Employee(4, 4000));  
	        // 内部比较器：要排序的对象要求实现了Comparable接口  
	        Collections.sort(employees);  
	        System.out.println("通过内部比较器实现：");  
	        System.out.println(employees);  
	          
	        List<Employee> employees2 = new ArrayList<Employee>();  
	        employees2.add(new Employee(2, 5000));  
	        employees2.add(new Employee(1, 4500));  
	        employees2.add(new Employee(4, 3500));  
	        employees2.add(new Employee(5, 3000));  
	        employees2.add(new Employee(4, 4000));  
	        // 外部比较器：自定义类实现Comparator接口  
	        Collections.sort(employees2, new EmployeeComparable());  
	        System.out.println("通过外部比较器实现：");  
	        System.out.println(employees2);  
	    }  
	  
	}  
	  

控制台打印:

通过内部比较器实现：
[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]