Java使用Comparable接口自定义排序

Java经典编程300例之实例063 使用Comparable接口自定义排序

案例见http://blog.csdn.net/the_star_is_at/article/details/70245219

实例说明

默认情况下，保存在List集合中的数组是不进行排序的，不过可以通过使用Comparable接口自定义排序规则并自动排序。本实例将介绍如何使用Comparable接口自定义排序规则并自动排序。

 

实现过程

新建一个Java类，名称为Employee。在该类中首先定义3个属性，分别是id（表示员工的编号）、name（表示员工的姓名）和age（表示员工的年龄），然后在构造方法中初始化这3个属性，最后再实现接口中定义的compareTo()方法，将对象按编号升序排列。

Employee.java

[java] view plain copy

1. public class Employee implements Comparable<Employee> {  
2.     private int id;  
3.     private String name;  
4.     private int age;  
5.     public Employee(int id, String name, int age) { //利用构造方法初始化各个域  
6.         this.id = id;  
7.         this.name = name;  
8.         this.age = age;  
9.     }  
10.     @Override  
11.     public int compareTo(Employee o) {              //利用编号实现对象间的比较  
12.         if (id > o.id) {  
13.             return 1;  
14.         } else if (id < o.id) {  
15.             return -1;  
16.         }  
17.         return 0;  
18.     }  
19.     @Override  
20.     public String toString() {                      //重写toString()方法  
21.         StringBuilder sb = new StringBuilder();  
22.         sb.append("员工的编号：" + id + "，");  
23.         sb.append("员工的姓名：" + name + "\t，");  
24.         sb.append("员工的年龄：" + age);  
25.         return sb.toString();  
26.     }  
27. }  

重写接口中的方法时，要将访问权限限定符设为public，因为接口中的方法默认就是public的。

 

再新建一个名称为Test的类，用于进行测试。在该类中首先定义一个List集合来保存3个Employee对象，并通过遍历输出集合中的元素，再通过Collections.sort()方法执行自动排序，最后再通过遍历输出排序后的集合中的元素。

Test.java

[java] view plain copy

1. import java.util.ArrayList;  
2. import java.util.Collections;  
3. import java.util.List;  
4.   
5. public class Test {  
6.     public static void main(String[] args) {  
7.         List<Employee> list = new ArrayList<Employee>();  
8.         list.add(new Employee(2, "Java", 20));  
9.         list.add(new Employee(1, "C", 30));  
10.         list.add(new Employee(3, "C#", 10));  
11.         System.out.println("排序前");  
12.         for (Employee employee : list) {  
13.             System.out.println(employee);  
14.         }  
15.         System.out.println("排序后");  
16.         Collections.sort(list);  
17.         for (Employee employee : list) {  
18.             System.out.println(employee);  
19.         }  
20.     }  
21. }  

编译运行

$javac Employee.Java Test.java

$java Test

排序前

员工的编号：2，员工的姓名：Java，员工的年龄：20

员工的编号：1，员工的姓名：C，员工的年龄：30

员工的编号：3，员工的姓名：C#，员工的年龄：10

排序后

员工的编号：1，员工的姓名：C，员工的年龄：30

员工的编号：2，员工的姓名：Java，员工的年龄：20

员工的编号：3，员工的姓名：C#，员工的年龄：10

 

技术要点

本实例主要一个月java.lang包中的Comparable接口来实现自定义排序规则。Comparable接口用于强行对实现它的每个类的对象进行整体排序，用于指定排序规则。Comparable接口的定义如下：

publicinterface Comparable<T> {

   int compareTo(T o);

}

当需要对一个对象进行排序时，该对象应该实现Comparable接口，并实现其唯一的方法compareTo()。在该方法中定义自己的排序规则，当调用Arrays.sort(Object[]a)或Collectons.sort(List<T> list)方法时会回调compareTo()方法，并按照自己的规则对对象数组或列表进行排序。

返回值及比较规则：

1、返回负值---->小于

2、返回零------>等于

3、返回正值---->大于

 

如果一个类要实现这个接口，可以使用如下语句声明：

publicclass Employee implements Comparable<Employee> {}

 

在Employee中必须实现接口中定义的compareTo()方法。实现该方法后，如果将该对象保存在列表中，那么可以通过执行Collections.sort()方法进行自动排序；如果保存在数组中，那么可以通过执行Arrays.sort()方法进行自动排序。

 

如果不想实现在接口中定义的方法，则可以将类声明为抽象类，将接口中定义的方法声明为抽象方法。