java list比较器_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 接口声明了： int compare 方法

比较用来排序的两个参数：

1)如果o1大于o2，则返回正整数；

2)如果o1小于o2，则返回负整数

3)如果o1等于o2，则返回零

2、java.lang.Comparable 接口声明了： int compareTo(T o) 方法

比较此对象与执行对象的顺序。比较规则同上，即：

1)如果此对象大于指定对象，返回正整数

2)如果此对象小于指定对象，返回负整数

3)如果此对象等于指定对象，返回零

下面举个简单的例子说明。

需求：对员工进行排序，员工有员工编号和薪资。排序要求：

1)按照员工的编号id进行排序

2)如果员工的编号id相等，则按照员工的薪资进行比较

上代码：

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

/**

* 员工实体

* @author Sam

*

*/

public class Employee implements Comparable {

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;

}

}

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

/**

* 测试两种比较器

* @author Sam

*

*/

public class TestEmployeeCompare {

/**

* @param args

*/

public static void main(String[] args) {

List employees = new ArrayList();

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 employees2 = new ArrayList();

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);

}

}

/**

* 自定义员工比较器

*

*/

class EmployeeComparable implements Comparator {

@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;

}

}

程序输出结果：

为了让大家较全，我把结果拷贝下来，如下：

通过内部比较器实现：

[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)方法，根据自己的需求定义比较规则。使用外部比较器这种方式比较灵活，例如现在需求是按照员工编号和薪资进行排序，以后可能按照姓名进行排序，这时只要再写一个按照姓名规则比较的比较器就可以了。

分享到：

2014-04-08 15:40

浏览 2468

评论