java Comparable 和Comparator 详解及区别

Java中，对集合对象或者数组对象排序，有两种实现方式。

即：（1）对象实现Comparable 接口

        （2）定义比较器，实现Comparator接口。

下面会简要介绍这两种方法的区别，并附上实现代码，供大家参考。

Comparable介绍

Comparable是在集合内部定义的方法实现的排序，位于java.lang下。

Comparable 接口仅仅只包括一个函数，它的定义如下：

1. package java.lang;  
2. import java.util.*;  
3.   
4.   
5. public interface Comparable<T> {  
6.       
7.     public int compareTo(T o);  
8. }  

若x.compareTo(y) <0，则x<y;若x.compareTo(y) =0，则x=y;若x.compareTo(y) >0，则x=y;

Comparable是一个对象，本身就已经支持自比较所需要实现的接口。

自定义类要在加入list容器中后能够排序，也可以实现Comparable接口。

在用Collections类的sort方法排序时若不指定Comparator，那就以自然顺序排序。所谓自然顺序就是实现Comparable接口设定的排序方式。

若一个类实现了comparable接口，则意味着该类支持排序。如String、Integer自己就实现了Comparable接口，可完成比较大小操作。

一个已经实现comparable的类的对象或数据，可以通过Collections.sort(list) 或者Arrays.sort(arr)实现排序。通过Collections.sort(list,Collections.reverseOrder());对list进行倒序排列。

Comparator介绍

Comparator是在集合外部实现的排序，位于java.util下。

Comparator接口包含了两个函数。

1. package java.util;  
2. public interface Comparator<T> {  
3.   
4.     int compare(T o1, T o2);  
5.     boolean equals(Object obj);  
6. }  

我们若需要控制某个类的次序,而该类本身不支持排序(即没有实现Comparable接口);那么，我们可以新建一个该类的比较器来进行排序。这个比较器只需要实现comparator即可。

如果引用的为第三方jar包，这时候，没办法改变类本身，可是使用这种方式。

Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足要求时，可写一个比较器来完成两个对象之间大小的比较。

Comparator体现了一种策略模式(strategy design pattern)，就是不改变对象自身，而用一个策略对象(strategy object)来改变它的行为。

comparable相当于内部比较器。comparator相当于外部比较器。

comparable实例

1. package test;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Collections;  
5. import java.util.List;  
6.   
7. public class test {  
8.     public static void main(String[] args) {  
9.         List<UserInfo> list = new ArrayList<UserInfo>();  
10.         list.add(new UserInfo(1,21,"name1"));  
11.         list.add(new UserInfo(2,27,"name1"));  
12.         list.add(new UserInfo(3,15,"name1"));  
13.         list.add(new UserInfo(5,24,"name1"));  
14.         list.add(new UserInfo(4,24,"name1"));  
15.         //对该类排序  
16.         Collections.sort(list);  
17.         for(int i=0;i<list.size();i++){  
18.             System.out.println(list.get(i));  
19.         }  
20.     }  
21. }  
22.   
23. class UserInfo implements Comparable<UserInfo>{  
24.     private int userid;  
25.     private int age;  
26.     private String name;  
27.     public UserInfo(int userid, int age, String name) {  
28.         this.userid = userid;  
29.         this.age = age;  
30.         this.name = name;  
31.     }  
32.     public int getUserid() {  
33.         return userid;  
34.     }  
35.     public void setUserid(int userid) {  
36.         this.userid = userid;  
37.     }  
38.     public int getAge() {  
39.         return age;  
40.     }  
41.     public void setAge(int age) {  
42.         this.age = age;  
43.     }  
44.     public String getName() {  
45.         return name;  
46.     }  
47.     public void setName(String name) {  
48.         this.name = name;  
49.     }  
50.     @Override  
51.     public String toString(){  
52.         return this.userid+","+this.age+","+this.name;  
53.     }  
54.     @Override  
55.     public int compareTo(UserInfo o) {  
56.         //如果年龄相同，则比较userid，也可以直接  return this.age-o.age;  
57.         if(this.age-o.age==0){  
58.             return this.userid-o.userid;  
59.         }else{  
60.             return this.age-o.age;  
61.         }  
62.     }  
63.   
64. }  

comparator实例

[java]  view plain  copy

 print ?

1. package test;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Collections;  
5. import java.util.Comparator;  
6. import java.util.List;  
7.   
8. public class test1 {  
9.     public static void main(String[] args) {  
10.         List<UserInfo> list = new ArrayList<UserInfo>();  
11.         list.add(new UserInfo(1,21,"name1"));  
12.         list.add(new UserInfo(2,27,"name2"));  
13.         list.add(new UserInfo(3,15,"name3"));  
14.         list.add(new UserInfo(5,24,"name4"));  
15.         list.add(new UserInfo(4,24,"name5"));  
16.         //new一个比较器  
17.         MyComparator comparator = new MyComparator();  
18.         //对list排序  
19.         Collections.sort(list,comparator);  
20.         for(int i=0;i<list.size();i++){  
21.             System.out.println(list.get(i));  
22.         }  
23.     }  
24. }  
25. class MyComparator implements Comparator<UserInfo>{  
26.     @Override  
27.     public int compare(UserInfo o1,UserInfo o2) {  
28.           
29.         if(o1.getAge()-o2.getAge()==0){  
30.             return o1.getUserid()-o2.getUserid();  
31.         }else{  
32.             return o1.getAge()-o2.getAge();  
33.         }  
34.     }  
35. }  
36. class UserInfo{  
37.     private int userid;  
38.     private int age;  
39.     private String name;  
40.     public UserInfo(int userid, int age, String name) {  
41.         this.userid = userid;  
42.         this.age = age;  
43.         this.name = name;  
44.     }  
45.     public int getUserid() {  
46.         return userid;  
47.     }  
48.     public void setUserid(int userid) {  
49.         this.userid = userid;  
50.     }  
51.     public int getAge() {  
52.         return age;  
53.     }  
54.     public void setAge(int age) {  
55.         this.age = age;  
56.     }  
57.     public String getName() {  
58.         return name;  
59.     }  
60.     public void setName(String name) {  
61.         this.name = name;  
62.     }  
63.     @Override  
64.     public String toString(){  
65.         return this.userid+","+this.age+","+this.name;  
66.     }  
67. }  

本文转自：http://blog.csdn.net/tolcf/article/details/52229068

最终版权