java集合中Comparable和Comparator辨析

一.Comparable和Comparator简介

在对集合元素进行比较时一般使用TreeSet.对于简单的数据类型，TreeSet可以直接进行比较。但是对于复杂的数据类型，比如自己定义的数据类型或者类，就需要自己设置比较方法与比较规则了，这时就需要使用Comparable和Comparator。 Comparable和Comparator都是用来实现集合中的排序的，只是Comparable是在集合内部定义的方法实现排序，而Comparator是在集合外部实现的排序。所以如果想对结合排序，需要在集合外定义Comparator接口的方法或在集合内部实现Comparable接口的方法。

一个类实现了Comparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的结合就可以直接使用sort方法排序。

Comparator是策略模式，就是在不改变对象自身，而用一种策略对象来改变它的行为，将算法和数据分离，Comparator还可以在下面两种环境下使用：

   1.类在设计时没有考虑到比较问题而没有实现Comparable接口，则可以通过Comparator来实现排序而不必修改原来的类代码。

2.类设计时实现了Comparable接口，但是后面的使用者却想用一种新的比较规则对类进行比较

二。用法示例：

Comparable排序：

首先定义实现Comparable接口的Item类

[java] view plain copy

 

1. package com.collection;  
2.    
3. import java.util.Objects;  
4.    
5. /** 
6.  * @author朱伟 
7.  * 定义实现Comparable接口的Item类 
8.  * 
9.  */  
10. public class Item implements Comparable<Item>{  
11.     private String description;  
12.     private int partNumber;  
13.      
14.     public Item(String aDescription, int aPartNumber)  
15.     {  
16.        description = aDescription;  
17.        partNumber = aPartNumber;  
18.     }  
19.      
20.     public String getDescription()  
21.     {  
22.        return description;  
23.     }  
24.      
25.     public String toString()  
26.     {  
27.        return "[description="+description+",partNumber="+partNumber+"]";  
28.     }  
29.      
30.     public boolean equals(Object otherObject)  
31.     {  
32.        if(this == otherObject)  
33.            return true;  
34.        if(otherObject == null)  
35.            return false;  
36.        if(getClass()!=otherObject.getClass())  
37.            return false;  
38.        Item other = (Item)otherObject;  
39.        return Objects.equals(description, other.description) &&partNumber == other.partNumber;  
40.     }  
41.      
42.     public int hashCode()  
43.     {  
44.        return Objects.hash(description,partNumber);  
45.     }  
46.    
47.     //重载compareTo方法，设定Item对象的比较方法  
48.     @Override  
49.     public int compareTo(Item other)  
50.     {  
51.         
52.        return Integer.compare(partNumber, other.partNumber);        
53.     }  
54.      
55.    
56. }  
57.    

 

定义对Item进行排序的类，对集合进行排序是使用TreeSet或TreeMap,此处用TreeSet存放集合元素。

[java] view plain copy

 

1. package com.collection;  
2.    
3. import java.util.TreeSet;  
4.    
5. public class ListSortWithComparable  
6. {  
7.    
8.     public static void main(String[] args)  
9.     {  
10.        TreeSet<Item> set = new TreeSet<>();  
11.        set.add(new Item("zhuwei",26));  
12.        set.add(new Item("yinyuchun",24));  
13.        set.add(new Item("xiaobai",25));  
14.        set.add(new Item("chun",24));  
15.         
16.        for(Item it : set)  
17.        {  
18.            System.out.println(it.toString());  
19.        }  
20.    
21.     }  
22.    
23. }  
24.    

Comparator排序实现示例：

首先定义需要排序的类People

[java] view plain copy

 

1. package com.collection;  
2.    
3. public class People  
4. {  
5.     private String name;  
6.     public String getName()  
7.     {  
8.        return name;  
9.     }  
10.     public void setName(String name)  
11.     {  
12.        this.name = name;  
13.     }  
14.     public int getAge()  
15.     {  
16.        return age;  
17.     }  
18.     public void setAge(int age)  
19.     {  
20.        this.age = age;  
21.     }  
22.     private int age;  
23.    
24.     public People(String name,int age)  
25.     {  
26.        this.name = name;  
27.        this.age = age;  
28.     }  
29.     public String toString()  
30.     {  
31.        return ("name:"+this.name+",age:"+this.age);  
32.     }  
33. }  

 

接着建立对People进行排序的类，利用Comparator进行排序有两种方法，第一种方法是把需要排序的People对象放在List集合中，然后调用Collection.sort(list,comparator)方法进行排序；第二中排序方法是直接把Comparator对象传递给TreeSet的构造器，并重载Comparator类的compara方法，指定排序规则，这种方法不需要让People类实现Comparator接口，且其代码较简洁。

Comparator

[java] view plain copy

 

1. package com.collection;  
2.    
3. import java.util.ArrayList;  
4. import java.util.Collection;  
5. import java.util.Collections;  
6. import java.util.Comparator;  
7. import java.util.HashSet;  
8. import java.util.List;  
9. import java.util.SortedSet;  
10. import java.util.TreeSet;  
11.    
12. public class ListSortWithComparator  
13. {    
14.     publicstatic void main(String[] args)  
15.     {  
16.        /* 
17.         * 使用comparator进行排序的第一种方法， 
18.         * 定义一个实现Comparator接口的类，并重载compara方法，设定比较规则 
19.         * 利用Collection.sort(list,comparator)方法实现排序， 
20.         * Collection.sort(list,comparator)方法的第一个参数为List类型，因此要排序的元素需要放在List集合中 
21.         */  
22.        List<People>list = new ArrayList<>();  
23.        list.add(newPeople("zhuwei",26));  
24.        list.add(newPeople("yinyuchun",25));  
25.        list.add(newPeople("xiaobai",26));  
26.    
27.        MComparatorcomparator = new MComparator();  
28.         
29.        Collections.sort(list,comparator);  
30.         
31.        for(Peoplep:list)  
32.        {  
33.            System.out.println(p.toString());  
34.        }  
35.         
36.         
37.        /* 
38.         * 使用comparator进行排序的第二种方法， 
39.          * 该方法不需要People实现Comparator接口 
40.         * 直接Comparator对象传递给TreeSet的构造器， 
41.         * 并重载Comparator类的compara方法，指定排序规则 
42.         */  
43. //     SortedSet<People>set = new TreeSet<>(  
44. //            newComparator<People>()  
45. //            {  
46. //  
47. //                //重载Comparator类的compara方法，设定比较规则:按名字降序排列  
48. //                @Override  
49. //                publicint compare(People people1, People people2)  
50. //                {  
51. //                   //TODO Auto-generated method stub  
52. //                   if(people1.getName().compareTo(people2.getName())>0)  
53. //                   {  
54. //                       return-1;  
55. //                   }  
56. //                   else  
57. //                   {  
58. //                       return1;  
59. //                   }  
60. //                    
61. //                }  
62. //                 
63. //            }  
64. //            );  
65. //     set.addAll(list);  
66. //     System.out.println("输出按降序排列的结果：");  
67. //     for(Peoplep: set)  
68. //     {  
69. //         System.out.println(p.toString());  
70. //     }  
71.     }  
72.    
73. }