设计模式之二：iterator

用途：

iterator 主要是针对不同容器，对外提供具有相同操作规范的遍历。因为不同容器内部具体实现不一样，所做的迭代也是不一样，为了便于程序的可扩展性，暴露一个接口，各个容器依据具体实现提供遍历方法。

代码实现：

//自定容器之一：MyArrayList 
public class MyArrayList {

    private int[] datas = new int[5];
    private int size=0;

    public void add(int number){
        if(size==datas.length){
            int[] newDatas = new int[datas.length*2];
            System.arraycopy(datas,0,newDatas,0,datas.length);
            datas =newDatas;
        }
        datas[size]=number;
        size++;
    }

    public int getSize(){
        return size;
    }

}


//自定义容器之二：MyLinkList 
public class MyLinkList {
     private Node head = null;
        private Node tail = null;
        private int size = 0;

        public void add(int number){
            Node newNode = new Node(number,null);
            if(head==null){//如果一个节点都没有，则head和tail都指向新的节点
                head = newNode;
                tail = newNode;
            }
            tail.setNext(newNode);
            tail = newNode;
            size++;
        }

        public int getSize(){
            return size;
        }

}

//Node类
public class Node {

    private int number;
    private Node next;

    public Node(int number, Node next) {
        this.number = number;
        this.next = next;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

}

//测试类：

public class Test {

    public static void main(String[] args) {
        //MyArrayList mya = new MyArrayList();
        MyLinkList  mya = new MyLinkList();

        for(int i = 0;i<12;i++){
            mya.add(i);
        }


        System.out.println(mya.getSize());
    }

}

从测试类中可以看出，每次我要换一个容器的时候，如果这两个容器的add和get方法不一致，代码变更量很大，所以改造之一：提供一个collection 接口，将add和
getSize方法统一在接口中：

//自定义接口：MyCollection
public interface MyCollection {

    void add(int number);
    int getSize();

}

//再看测试类：
public static void main(String[] args) {

        MyCollection c  = new MyLinkList();

        for(int i = 0;i<12;i++){
            c.add(i);
        }

        System.out.println(c.getSize());
    }

现在想遍历这2个容器，可以看到由于内部具体实现不同，设计一个迭代器，不同容器提供这个迭代器供外部使用，改造开始：

//迭代器：
public interface MyIterator {

int next();
boolean hasNext();

}

//MyArrayList 提供自己的迭代器
public class MyArrayList implements MyCollection{

private int[] datas = new int[5];
private int size=0;

public void add(int number){
    if(size==datas.length){
        int[] newDatas = new int[datas.length*2];
        System.arraycopy(datas,0,newDatas,0,datas.length);
        datas =newDatas;
    }
    datas[size]=number;
    size++;
}

public int getSize(){
    return size;
}

@Override
public MyIterator iterator() {

    return new ArrayIterator();
}

class ArrayIterator implements MyIterator{
    int index = 0;

    @Override
    public int next() {
        int temp = datas[index];
        index++;
        return temp;
    }

    @Override
    public boolean hasNext() {
        if(index>=size){
            return false;
        }else{
            return true;
        }

    }


}

}

//MyCollection  新增一个提供Iterator的方法：
public interface MyCollection {

    void add(int number);
    int getSize();
    MyIterator iterator();
}


测试：
public static void main(String[] args) {

        MyCollection c  = new MyArrayList();
        for(int i = 0;i<12;i++){
            c.add(i);
        }
        MyIterator it = c.iterator();

        while(it.hasNext()){
            int number = it.next();
            System.out.print(number+" ");
        }



    }

打印结果：0 1 2 3 4 5 6 7 8 9 10 11