迭代器模式

迭代器模式可以說經(jīng)常在用，也可以說不常用，他一般用在集合里面的遍歷。（JDK已經(jīng)幫我們實現(xiàn)了，所以我們經(jīng)常用別人寫好的，只是不知道而已）

計算機的物理存儲，只分為2個類型，隨機存儲，順序存儲，JAVA里的集合的典型代表是ArrayList,LinkList,他們的遍歷方式是不同的，如果外部類想要對他們進行遍歷的話，不同的集合要寫不同的算法，迭代器模式就是解決這個問題（集合你自己去實現(xiàn)好遍歷，我外部只管調(diào)用你提供方法就好了）

第一步，手寫ArrayList,LinkList源碼實現(xiàn),首先抽離公共接口為Collection_
public interface Collection_ {
    void add(Object o);
    int size();
}
arraylist 底層是順序存儲，所以用數(shù)組來存
public class ArrayList_ implements Collection_{
    private Object[] objects = new Object[10];//初始化一個10個大小數(shù)組
    private int index=0;//記錄數(shù)組大小，同時也當下標使用

    @Override
    public void add(Object o) {
        if(index>=objects.length){
            //如果放置的元素最后一個時候，那么先擴容為2倍
            Object[] newobjects = new Object[objects.length*2];
            System.arraycopy(objects,0,newobjects,0,objects.length);
            objects=newobjects;
        }

        objects[index]=o;
        index++;
    }

    @Override
    public int size() {
        return index;
    }
}
linklist 采用鏈表形式，先造一個Node類來包裝，也就是所謂的單個鏈條元素
public class Node {
    private Object object;
    private Node next;

    public Node(Object object) {
        this.object = object;
    }



    public Node getNext() {
        return next;
    }

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


public class LinkList_ implements Collection_{
    Node head=null;//頭指針
    Node tail=null;//尾指針
    int size=0;
    @Override
    public void add(Object o) {
        Node node= new Node(o);//鏈表需要Node包裹對象
        if(head==null){
            //如果頭指針沒用持對象，當作是空表
            head=node;
            tail=node;
        }
        tail.setNext(node); //舊的尾節(jié)點保存下一個節(jié)點的信息，把新節(jié)點加進來
        tail=node;//tail節(jié)點離開舊節(jié)點，指向新加進來的node
        size++;//長度增加

    }

    @Override
    public int size() {
        return size;
    }
}
本期主題是迭代器模式，就是要遍歷集合內(nèi)元素，但是這些集合寫法不一樣，不能統(tǒng)一到一個共同方法，但是可以讓他們都繼承一個接口，在接口里面他們自己去實現(xiàn)，外面的人只管調(diào)用他們繼承的接口，不管他們的內(nèi)部是怎么實現(xiàn)的
//新增接口
public interface Iterator_ {
        boolean hasNext();

        Object next();
}

//調(diào)整接口
public interface Collection_<E> {
    void add(E o);
    int size();

    Iterator_ iterator();
}
修改后array和link
public class ArrayList_ implements Collection_{
    private Object[] objects = new Object[10];//初始化一個10個大小數(shù)組
    private int index=0;//記錄數(shù)組大小，同時也當下標使用

    @Override
    public void add(Object o) {
        if(index>=objects.length){
            //如果放置的元素最后一個時候，那么先擴容為2倍
            Object[] newobjects = new Object[objects.length*2];
            System.arraycopy(objects,0,newobjects,0,objects.length);
            objects=newobjects;
        }

        objects[index]=o;
        index++;
    }

    @Override
    public int size() {
        return index;
    }

    @Override
    public Iterator_ iterator() {

        return new ArrayListIterator();
    }

    private class ArrayListIterator implements Iterator_ {
        private int currentindex=0;//當前索引
        @Override
        public boolean hasNext() {
            if(currentindex>=index)
            return false;
            return true;
        }

        @Override
        public Object next() {
            Object object = objects[currentindex];
            currentindex++;
            return object;
        }
    }
}




public class MyLinkList implements ZCollection {
    Node head = null;
    Node tail = null;
    private int size=0;
    @Override
    public void add(Object o) {
        Node n=new Node(o);
        if (head == null) {
            head=n;
            tail=n;
        }
        tail.setNext(n);
        tail=n;
        size++;

    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public Iterator_ interator() {
        return new LinkListIterator();
    }

    private class LinkListIterator implements Iterator_ {
        private int currentindex=0;

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

        @Override
        public Object next() {
            int offset=0;
            Node check = check(offset, head);
            currentindex++;
            return check;
        }

        private Node check(int offset, Node node) {
            if (offset == currentindex) {
                return node;
            }else{
              return check(++offset,node.getNext());
            }
        }

    }
}
為了更加和jdk 提供的array和link相像，把Object 對象統(tǒng)一換成泛型E
public interface Collection_<E> {
    void add(E o);
    int size();
    Iterator_ iterator();
}


public interface Iterator_<E> {
        boolean hasNext();

        E next();
}

public class ArrayList_<E> implements Collection_<E>{
    private E[] objects = (E[]) new Object[10];//初始化一個10個大小數(shù)組
    private int index=0;//記錄數(shù)組大小，同時也當下標使用

    @Override
    public void add(E o) {
        if(index>=objects.length){
            //如果放置的元素最后一個時候，那么先擴容為2倍
            E[] newobjects = (E[]) new Object[objects.length*2];
            System.arraycopy(objects,0,newobjects,0,objects.length);
            objects=newobjects;
        }

        objects[index]=o;
        index++;
    }

    @Override
    public int size() {
        return index;
    }

    @Override
    public Iterator_ iterator() {

        return new ArrayListIterator();
    }

    private class ArrayListIterator<E> implements Iterator_<E> {
        private int currentindex=0;//當前索引
        @Override
        public boolean hasNext() {
            if(currentindex>=index)
            return false;
            return true;
        }

        @Override
        public E next() {
            E object = (E) objects[currentindex];
            currentindex++;
            return object;
        }
    }
}


public class LinkList_<E> implements Collection_<E>{
    Node head=null;//頭指針
    Node tail=null;//尾指針
    int size=0;
    @Override
    public void add(E o) {
        Node node= new Node(o);//鏈表需要Node包裹對象
        if(head==null){
            //如果頭指針沒用持對象，當作是空表
            head=node;
            tail=node;
        }
        tail.setNext(node); //舊的尾節(jié)點保存下一個節(jié)點的信息，把新節(jié)點加進來
        tail=node;//tail節(jié)點離開舊節(jié)點，指向新加進來的node
        size++;//長度增加

    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public Iterator_ iterator() {
        return new LinkListIterator();
    }

    private class LinkListIterator implements Iterator_ {
        private int currentindex=0;
        @Override
        public boolean hasNext() {
            if (currentindex >= size) {
                return false;
            }
            return true;
        }

        @Override
        public Object next() {
            int offset=0;
            Node node = getNode(offset, head);
            return node;
        }

        private Node getNode(int offset, Node node) {
            if (offset == currentindex) {
                //相等說明指定的就是要的節(jié)點，否則前進一步去拿下一個節(jié)點
                return node;
            }else{
                return getNode(++offset,node.getNext());
            }
        }
    }
}
最后場景類驗證
public class Client {
    public static void main(String[] args) {
        Collection_<String> mytest=new ArrayList_<>();
        for (int i = 0; i < 5; i++) {
            mytest.add(i+"");
        }

        Iterator_ iterator = mytest.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.err.println(next);
        }
    }
}
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

友情鏈接更多精彩內(nèi)容