Java提高篇（5）-对象比较器

在Java中要想对两个对象进行比较大小，需要实现Comparable接口或Comparator接口。String类型的值之所以可以比较大小（汉字根据ANSI值的大小进行比较），是因为String类实现了Comparable<T>接口。如果要比较的对象没有实现Comparable接口或Comparator接口而直接比较会报 java.lang.ClassCastException类型转换异常。

两个对象进行比较方法一：实现Comparable<T>接口

Person类是要比较的对象

[java]  view plain  copy

1. package com.lym.comparator;  
2. /** 
3.  * 人类 
4.  * 要使该类能进行比较，该类必须实现Comparable接口 
5.  * @author Administrator 
6.  * 
7.  */  
8. public class Person implements Comparable<Person>{  
9.   
10.     private String name;  
11.     private int age;  
12.     public Person() {  
13.         super();  
14.     }  
15.     public Person(String name, int age) {  
16.         super();  
17.         this.name = name;  
18.         this.age = age;  
19.     }  
20.     public String getName() {  
21.         return name;  
22.     }  
23.     public void setName(String name) {  
24.         this.name = name;  
25.     }  
26.     public int getAge() {  
27.         return age;  
28.     }  
29.     public void setAge(int age) {  
30.         this.age = age;  
31.     }  
32.     @Override  
33.     public String toString() {  
34.         return "Person [name=" + name + ", age=" + age + "]";  
35.     }  
36.     //当前类按年龄由小到大排序  
37.     //1和-1调换后就是按年龄由大到小排序的  
38.     @Override  
39.     public int compareTo(Person o) {  
40.         if(o == null){  
41.             throw new NullPointerException();  
42.         }  
43.         if(this.age>o.age){  
44.             return 1;  
45.         }else if(this.age<o.age){  
46.             return -1;  
47.         }  
48.         return 0;//相等  
49.     }  
50.       
51. }  

方法二：实现Comparator<T>接口

实现Comparator<T>接口与Comparable<T>接口有什么区别吗？

答：Comparable<T>接口 是在要比较的对象类创建的时候就实现了，也就是在项目上线之前就设计好了，大多数时候是采用这种方法。但是，有的时候项目已经上线了，此时我们还要对某个类进行比较，而此时该类还没有实现Comparable<T>接口，为了遵守软件开发中“对扩展开放，对修改关闭”的原则，我们可以再定义一个比较器类，实现Comparator<T>接口，这样我们就不会破坏要比较的类的原有结构了。

自定义比较器类

[java]  view plain  copy

1. package com.lym.comparator;  
2.   
3. import java.util.Comparator;  
4.   
5. /** 
6.  * 自定义比较器类 
7.  *  
8.  * @author Administrator 
9.  *  
10.  */  
11. public class ComparatorDemo implements Comparator<Person2> {  
12.   
13.     @Override  
14.     public int compare(Person2 o1, Person2 o2) {  
15.         if (o1 == null || o2 == null) {  
16.             throw new NullPointerException();// 空指针异常  
17.         }  
18.         if (o1.getAge() > o2.getAge()) {  
19.             return 1;  
20.         } else if (o1.getAge() < o2.getAge()) {  
21.             return -1;  
22.         }  
23.         return 0;  
24.     }  
25.   
26. }  

Person2类

[java]  view plain  copy

1. package com.lym.comparator;  
2.   
3. /** 
4.  * 人类 
5.  *  
6.  * @author Administrator 
7.  *  
8.  */  
9. public class Person2 {  
10.   
11.     private String name;  
12.     private int age;  
13.   
14.     public Person2() {  
15.         super();  
16.     }  
17.   
18.     public Person2(String name, int age) {  
19.         super();  
20.         this.name = name;  
21.         this.age = age;  
22.     }  
23.   
24.     public String getName() {  
25.         return name;  
26.     }  
27.   
28.     public void setName(String name) {  
29.         this.name = name;  
30.     }  
31.   
32.     public int getAge() {  
33.         return age;  
34.     }  
35.   
36.     public void setAge(int age) {  
37.         this.age = age;  
38.     }  
39.   
40.     @Override  
41.     public String toString() {  
42.         return "Person2 [name=" + name + ", age=" + age + "]";  
43.     }  
44.   
45. }  

对象比较器测试类

[java]  view plain  copy

1. package com.lym.comparator;  
2.   
3. import java.util.Arrays;  
4.   
5. /** 
6.  * 对象比较器测试类 
7.  * @author Administrator 
8.  * 
9.  */  
10. public class ComparableDemo {  
11.   
12.     public static void main(String[] args) {  
13.         String[] names = {"利亚","藤兰","泉彩","井空","岛爱","结衣"};  
14.           
15.         Person[] persons = {  
16.                 new Person("泉彩",23),new Person("岛爱",25),  
17.                 new Person("藤兰",41),new Person("结衣",35),  
18.                 new Person("利亚",28),new Person("井空",32)  
19.         };  
20.           
21.         Person2[] persons2 = {  
22.                 new Person2("泉彩",23),new Person2("岛爱",25),  
23.                 new Person2("藤兰",41),new Person2("结衣",35),  
24.                 new Person2("利亚",28),new Person2("井空",32)  
25.         };  
26.           
27.         Arrays.sort(names);  
28.         System.out.println(Arrays.toString(names));  
29.           
30.         //实现Comparable<T>接口  
31.         Arrays.sort(persons);//按Person对象的age属性比较大小  
32.         System.out.println(Arrays.toString(persons));//输出比较后的对象数组  
33.           
34.         //自定义比较器，实现Comparator<T>接口  
35.         Arrays.sort(persons2);  
36.         System.out.println(Arrays.toString(persons2));  
37.     }  
38.   
39. }