Java设计模式——Comparable接口&&Comparator（CC系）策略模式的应用

Comparable接口&&Comparator接口：突然想起了民国时期的CC系，哈哈^_^

转自：http://www.cnblogs.com/baizhanshi/p/6201875.html

Comparable

Comparable可以认为是一个内比较器，实现了Comparable接口的类有一个特点，就是这些类是可以和自己比较的，至于具体和另一个实现了Comparable接口的类如何比较，则依赖compareTo方法的实现，compareTo方法也被称为自然比较方法。如果开发者add进入一个Collection的对象想要Collections的sort方法帮你自动进行排序的话，那么这个对象必须实现Comparable接口。compareTo方法的返回值是int，有三种情况：

1、比较者大于被比较者（也就是compareTo方法里面的对象），那么返回正整数

2、比较者等于被比较者，那么返回0

3、比较者小于被比较者，那么返回负整数

实现了这个接口说明该对象具有可比性；

写个很简单的例子：

public class Domain implements Comparable<Domain>{    private String str;    public Domain(String str)    {        this.str = str;    }    public int compareTo(Domain domain)    {        if (this.str.compareTo(domain.str) > 0)            return 1;        else if (this.str.compareTo(domain.str) == 0)            return 0;        else             return -1;    }        public String getStr()    {        return str;    }}

public static void main(String[] args)    {        Domain d1 = new Domain("c");        Domain d2 = new Domain("c");        Domain d3 = new Domain("b");        Domain d4 = new Domain("d");        System.out.println(d1.compareTo(d2));        System.out.println(d1.compareTo(d3));        System.out.println(d1.compareTo(d4));    }

运行结果为：

01-1

注意一下，前面说实现Comparable接口的类是可以支持和自己比较的，但是其实代码里面Comparable的泛型未必就一定要是Domain，将泛型指定为String或者指定为其他任何任何类型都可以----只要开发者指定了具体的比较算法就行。

 

Comparator

Comparator可以认为是是一个外比较器，个人认为有两种情况可以使用实现Comparator接口的方式：

1、一个对象不支持自己和自己比较（没有实现Comparable接口），但是又想对两个对象进行比较

2、一个对象实现了Comparable接口，但是开发者认为compareTo方法中的比较方式并不是自己想要的那种比较方式

Comparator接口里面有一个compare方法，方法有两个参数T o1和T o2，是泛型的表示方式，分别表示待比较的两个对象，方法返回值和Comparable接口一样是int，有三种情况：

1、o1大于o2，返回正整数

2、o1等于o2，返回0

3、o1小于o3，返回负整数

实现了这个接口说明想自定义比较的策略

写个很简单的例子，上面代码的Domain不变（假设这就是第2种场景，我对这个compareTo算法实现不满意，要自己写实现）：

public class DomainComparator implements Comparator<Domain>{    public int compare(Domain domain1, Domain domain2)    {        if (domain1.getStr().compareTo(domain2.getStr()) > 0)            return 1;        else if (domain1.getStr().compareTo(domain2.getStr()) == 0)            return 0;        else             return -1;    }}

public static void main(String[] args){    Domain d1 = new Domain("c");    Domain d2 = new Domain("c");    Domain d3 = new Domain("b");    Domain d4 = new Domain("d");    DomainComparator dc = new DomainComparator();    System.out.println(dc.compare(d1, d2));    System.out.println(dc.compare(d1, d3));    System.out.println(dc.compare(d1, d4));}

看一下运行结果：

01-1

当然因为泛型指定死了，所以实现Comparator接口的实现类只能是两个相同的对象（不能一个Domain、一个String）进行比较了，因此实现Comparator接口的实现类一般都会以"待比较的实体类+Comparator"来命名.

在自己的项目中获取对象集合中如果在sql中没有进行预排序，可以在这儿进行排序，例如：

1

2

3

4

5

6

7

List<PartAreaDto> partAreaDtoList = ruleService.getPartAreaList();

       Collections.sort(partAreaDtoList, new Comparator<PartAreaDto>() {

           @Override

           public int compare(PartAreaDto o1, PartAreaDto o2) {

               return o2.getAreaCode().compareTo(o1.getAreaCode());

           }

       });

　

1

Collections.sort这样比较以后 list集合就会按照areaCode 进行正序排列，如果是Collections.reverse()则会按照areaCode进行倒序排列。　

总结

总结一下，两种比较器Comparable和Comparator，后者相比前者有如下优点：

1、如果实现类没有实现Comparable接口，又想对两个类进行比较（或者实现类实现了Comparable接口，但是对compareTo方法内的比较算法不满意），那么可以实现Comparator接口，自定义一个比较器，写比较算法

2、实现Comparable接口的方式比实现Comparator接口的耦合性要强一些，如果要修改比较算法，要修改Comparable接口的实现类，而实现Comparator的类是在外部进行比较的，不需要对实现类有任何修改。从这个角度说，其实有些不太好，尤其在我们将实现类的.class文件打成一个.jar文件提供给开发者使用的时候。实际上实现Comparator接口的方式后面会写到就是一种典型的策略模式。

当然，这不是鼓励用Comparator，意思是开发者还是要在具体场景下选择最合适的那种比较器而已。

转自：http://blog.csdn.net/acmman/article/details/46634355

在遍历容器元素的时候，有很多初学者在疑惑，为什么返回一个iterator我就能够去遍历这个容器了呢？

今天我们就来深入剖析一下迭代器iterator的设计模式(循序渐进的剖析，一定要耐心看完)

iterator是"四人帮"所定义的23种设计模式之一(不太难，也不是非常重要，只是在遍历容器的时候能够用到)

首先需要读这个总结的同志掌握面向对象的思想。

1.我们先自己写一个可以动态添加对象的容器
建立一个新的Java工程：Iterator
创建一个包：cn.edu.hpu.iterator
在包下创建类ArrayList：
我们要在容器内首先添加一个add方法，用于向容器内添加元素
再写一个size方法，用于查找容器元素个数

ArrayList.java:

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. public class ArrayList {  
4.     //我们要用数组模拟一个可以添加任意大小元素的容器  
5.     //首先我们固定一个数组空间，再添加元素的时候，我们去判断  
6.     //这个空间是不是满了，如果满了再在此基础上再添加一个固定空间  
7.     //往下依次类推，这样就有了可以添加任意大小元素的容器  
8.     //当然，容器大小一定不可能超过计算机内存的大小  
9.     Object[] objects=new Object[10];   
10.     int index=0;//代表objects的下一个空的位置在哪里  
11.       
12.     //添加元素方法  
13.     public void add(Object o){  
14.         if(index==objects.length){  
15.             //原来的数组已满，要做扩展(原长度X2)  
16.             Object[] newObjects=new Object[objects.length*2];  
17.             //把objects内容拷贝到新的数组newObjects上  
18.             System.arraycopy(objects, 0, newObjects, 0, objects.length);//数组拷贝函数  
19.             objects=newObjects;//之后把newObjects拷贝给objects数组  
20.         }  
21.         objects[index]=o;  
22.         index++;  
23.     }  
24.       
25.     //获取容器元素个数方法  
26.     public int size(){  
27.         return index;  
28.     }  
29. }  

测试:

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. import cn.edu.hpu.iterator.ArrayList;  
4.   
5. public class ArrayListTest {  
6.     public static void main(String[] args) {  
7.         ArrayList al=new ArrayList();  
8.         for(int i=0;i<20;i++){  
9.             al.add(new Object());  
10.         }  
11.         System.out.println(al.size());  
12.     }  
13. }  

测试结果:20

我们就完成了这样一个容器，这个容器是用数组来实现的。容器比数组好在哪里呢？使用容器就不需要考虑到数组的边界问题了，容器可以动态拓展。想往里面装就add就行了，想知道大小直接size就可以了。

2.我们加一个辅助类Cat
Cat.java:

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. public class Cat {  
4.     private int id;  
5.   
6.   
7.     public Cat(int id) {  
8.         super();  
9.         this.id = id;  
10.     }  
11.       
12.     public int getId() {  
13.         return id;  
14.     }  
15.       
16.     public void setId(int id) {  
17.         this.id = id;  
18.     }  
19. }  

以后添加元素就添加这个就可以了，因为可以通过id值知道添加了哪些数据
如测试:

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. import cn.edu.hpu.iterator.ArrayList;  
4.   
5. public class ArrayListTest {  
6.     public static void main(String[] args) {  
7.         ArrayList al=new ArrayList();  
8.         for(int i=0;i<20;i++){  
9.             al.add(new Cat(i));  
10.         }  
11.         System.out.println(al.size());  
12.     }  
13. }  

3.OK，现在我腻歪了，不想用ArrayList容器了，我想用其它容器去装Cat，这个新的容器我们底层不用数组实现了，我们用链表来实现。（需要你先了解数据结构中的链表概念）
建立一个新容器类LinkedList,一个节点类Node
LinkedList.java:

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. public class LinkedList {  
4.     Node head=null;//头节点(以后的元素通过next得到)  
5.     Node tail=null;//尾节点  
6.     int size=0;  
7.     public void add(Object o){  
8.         Node n=new Node(o,null);  
9.         if(head==null){  
10.             head=n;  
11.             tail=n;  
12.         }  
13.         tail.setNext(n);  
14.         tail=n;  
15.         size++;  
16.           
17.     }  
18.       
19.     public int size(){  
20.         return size;  
21.     }  
22. }  

Node.java:

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. public class Node {  
4.     private Object data;  
5.     private Node next;  
6.       
7.       
8.     public Node(Object data, Node next) {  
9.         super();  
10.         this.data = data;  
11.         this.next = next;  
12.     }  
13.       
14.     public Object getData() {  
15.         return data;  
16.     }  
17.       
18.     public void setData(Object data) {  
19.         this.data = data;  
20.     }  
21.       
22.     public Node getNext() {  
23.         return next;  
24.     }  
25.       
26.     public void setNext(Node next) {  
27.         this.next = next;  
28.     }  
29.       
30. }  

测试:

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. import cn.edu.hpu.iterator.LinkedList;  
4.   
5. public class LinkedListTest {  
6.     public static void main(String[] args) {  
7.         LinkedList ll=new LinkedList();  
8.         for(int i=0;i<20;i++){  
9.             ll.add(new Cat(i));  
10.         }  
11.         System.out.println(ll.size());  
12.     }  
13. }  

测试结果:20


我们实现了两个内部原理完全不同的容器，那么下面我们来看:

4.考虑容器的可替换性
什么叫做可替换性？考虑我们使用容器的客户端类，想使这些容器可以任意的替换，其它代码不用改变，这就需要我们把所有容器的对外提供的方法统一起来。
解决方案:
我们写一个统一的接口Collection，定义一些统一的规范，让所有容器去实现这个接口。
Collection.java:

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. public interface Collection {  
4.     void add(Object o);  
5.     int size();  
6. }  

ArrayList.java:

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. public class ArrayList implements Collection{  
4.       
5.     Object[] objects=new Object[10];   
6.     int index=0;  
7.     public void add(Object o){  
8.         if(index==objects.length){  
9.               
10.             Object[] newObjects=new Object[objects.length*2];  
11.               
12.             System.arraycopy(objects, 0, newObjects, 0, objects.length);  
13.             objects=newObjects;  
14.         }  
15.         objects[index]=o;  
16.         index++;  
17.     }  
18.       
19.     public int size(){  
20.         return index;  
21.     }  
22. }  

LinkedList.java:

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. public class LinkedList implements Collection{  
4.     Node head=null;  
5.     Node tail=null;  
6.     int size=0;  
7.     public void add(Object o){  
8.         Node n=new Node(o,null);  
9.         if(head==null){  
10.             head=n;  
11.             tail=n;  
12.         }  
13.         tail.setNext(n);  
14.         tail=n;  
15.         size++;  
16.           
17.     }  
18.       
19.     public int size(){  
20.         return size;  
21.     }  
22. }  

这样我们就用Collection接口来实现对不同容器对外方法的统一。
在我们测试的时候就可以使用这种方式来实现容器:
Collection c=new ArrayList();
我对ArrayList不满意，就可以改成
Collection c=new LinkedList();

小结：针对接口编程就不需要考虑具体的实现类是什么，所以你的程序会更加灵活，要替换其它实现的时候，只需换一个位置(当然如果你写在配置文件上，你连代码都不用改)。

5.接下来重点来了，我们的容器需要一个非常非常重要的功能-------遍历
我想遍历容器中的所有元素，如何去做？
当然可以这样来写:

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. import cn.edu.hpu.iterator.ArrayList;  
4. import cn.edu.hpu.iterator.Collection;  
5.   
6. public class ArrayListTest {  
7.     public static void main(String[] args) {  
8.         Collection c=new ArrayList();  
9.         for(int i=0;i<20;i++){  
10.             c.add(new Cat(i));  
11.         }  
12.         System.out.println(c.size());  
13.           
14.         ArrayList al=(ArrayList)c;  
15.         for(int i=0;i<al.index;i++){  
16.             Cat cat=(Cat)al.objects[i];  
17.             System.out.print(cat.getId()+" ");  
18.         }  
19.     }  
20. }  

结果:
20
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 

但是，当我们将Collection的实现改为LinkedList的时候下面的遍历方法就不行了。
这个时候就需要一种统一的遍历方式。

每一种容器都应该有它自己的一种遍历方式，我们要想方设法的给他们统一起来，但是每种容器的遍历器的实现又不一样，所以统一遍历方式只能用一种共同的实现方式，接口或抽象类的方式。

所以我们这么写：
定义一个接口Iterator：

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. public interface Iterator {  
4.     Object next();  
5.     boolean hasNext();  
6. }  

其中有两个未实现的方法:next和hasNext。
我要求任何一个容器都必须给我一个实现了这个接口的类的对象，
具体的实现交给具体的容器自己去实现。实现完了之后，我肯定知道，
这个对象就实现这两个方法了，有了这两个方法，我就可以实现对这
个容器的遍历了。

我们在Collection中加入返回Iterator的未实现方法

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. public interface Collection {  
4.     void add(Object o);  
5.     int size();  
6.     Iterator iterator();  
7. }  

ArrayList实现了iterator()这个方法

[java] view plain copy

 

1. public Iterator iterator(){  
2.         return null;  
3.     }  

测试:

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. import cn.edu.hpu.iterator.ArrayList;  
4. import cn.edu.hpu.iterator.Collection;  
5. import cn.edu.hpu.iterator.Iterator;  
6.   
7. public class ArrayListTest {  
8.     public static void main(String[] args) {  
9.         Collection c=new ArrayList();  
10.         for(int i=0;i<20;i++){  
11.             c.add(new Cat(i));  
12.         }  
13.         System.out.println(c.size());  
14.           
15.         /*之前的方法 
16.                 ArrayList al=(ArrayList)c; 
17.         for(int i=0;i<al.index;i++){ 
18.             Cat cat=(Cat)al.objects[i]; 
19.             System.out.print(cat.getId()+" "); 
20.         }*/  
21.   
22.                 //使用统一遍历器的遍历方法  
23.                 ArrayList al=(ArrayList)c;  
24.         Iterator it=c.iterator();  
25.         while(it.hasNext()){  
26.             Object o=it.next();  
27.             Cat cat=(Cat)o;  
28.             System.out.print(cat.getId()+" ");  
29.         }  
30.     }  
31. }  

这样我们怎么改变Collection的实现类，都不影响遍历方式。

6.当然我没还没有写Iterator的实现，我们来写实现：
我们在ArrayList中写一个内部类ArrayListIterator，实现Iterator接口：

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. public class ArrayList implements Collection{  
4.   
5.     Object[] objects=new Object[10];   
6.     int index=0;  
7.       
8.     public void add(Object o){  
9.         if(index==objects.length){  
10.               
11.             Object[] newObjects=new Object[objects.length*2];  
12.       
13.             System.arraycopy(objects, 0, newObjects, 0, objects.length);  
14.             objects=newObjects;  
15.         }  
16.         objects[index]=o;  
17.         index++;  
18.     }  
19.       
20.     public int size(){  
21.         return index;  
22.     }  
23.       
24.     public Iterator iterator(){  
25.         return new ArrayListIterator();  
26.     }  
27.       
28.     private class ArrayListIterator implements Iterator{  
29.   
30.   
31.         private int currentIndex=0;  
32.           
33.         @Override  
34.         public boolean hasNext() {  
35.             if(currentIndex>index) return false;  
36.             else return true;  
37.         }  
38.   
39.         @Override  
40.         public Object next() {  
41.             Object o=objects[currentIndex];  
42.             currentIndex++;  
43.             return o;  
44.         }  
45.           
46.     }  
47. }  

测试:

[java] view plain copy

 

1. package cn.edu.hpu.iterator;  
2.   
3. import cn.edu.hpu.iterator.ArrayList;  
4. import cn.edu.hpu.iterator.Collection;  
5. import cn.edu.hpu.iterator.Iterator;  
6.   
7.   
8. public class ArrayListTest {  
9.     public static void main(String[] args) {  
10.         Collection c=new ArrayList();  
11.         for(int i=0;i<20;i++){  
12.             c.add(new Cat(i));  
13.         }  
14.         System.out.println(c.size());  
15.   
16.   
17.                 //使用统一遍历器的遍历方法  
18.         ArrayList al=(ArrayList)c;  
19.         Iterator it=c.iterator();  
20.         while(it.hasNext()){  
21.             Object o=it.next();  
22.             Cat cat=(Cat)o;  
23.             System.out.print(cat.getId()+" ");  
24.         }  
25.     }  
26. }  

测试结果:
20
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 

在我们的JavaAPI中的ArrayList也实现了Java的Collection接口，同样提供了一个方法，
叫iterator()，这个方法返回了一个实现了Iterator接口的对象。

现在大家明白iterator()方法到底是干什么用的，它返回的接口又是什么意思了吧？

作业:
这个LinkedList也需要写一个iterator方法，返回一个实现了Iterator的对象。该如何写？

这是我自己写的:http://blog.csdn.net/acmman/article/details/43924261

感谢马士兵老师的"设计模式"视频提供的帮助
转载请注明出处:http://blog.csdn.net/acmman/article/details/43920153