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));
    }
复制代码
复制代码

运行结果为:

0
1
-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));
}
复制代码
复制代码

看一下运行结果:

0
1
-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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  1. public Iterator iterator(){  
  2.         return null;  
  3.     }  

测试:
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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
 在CODE上查看代码片派生到我的代码片
  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


阅读更多

没有更多推荐了,返回首页