设计模式：Iterator Pattern(迭代器模式) 手写简单实现Iterator Collection ArrayList LinkedList

设计模式应用场景

需要为聚合对象提供多种遍历方式，为遍历不同的聚合结构提供一个统一的接口。

---

实现方式

提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。

Iterator

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

Collection

public interface Collection_<E>{

    //添加
    boolean add(E e);

    //获取长度
    int size();

    //是否有下一个
    boolean isEmpty();

    //获取迭代器
    Iterator_<E> iterator();
}

ArrayList

public class ArrayList_<E> implements Collection_<E>{

    private E[] objects = (E[]) new Object[10];

    private int size = 0;

    /*
    * 新增
    * */
    @Override
    public boolean add(E e) {
        ensureCapacityInternal(size+1);
        objects[size++] = e;
        return true;
    }

    /*
    * 是否扩容
    * */
    private void ensureCapacityInternal(int size){
      if (size >= objects.length){
          E[] newObjects = (E[])new Object[objects.length*2];
          System.arraycopy(objects, 0, newObjects, 0, objects.length);
          objects = newObjects;
      }
    }

    /*
    * 获取长度
    * */
    @Override
    public int size() {
        return size;
    }

    /*
    * 集合是否为空
    * */
    @Override
    public boolean isEmpty() {
        return size==0?true:false;
    }

    /*
    * 获取迭代器
    * */
    @Override
    public Iterator_ iterator() {
        return new Iterator_() {

            private int currentIndex = 0;

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

            @Override
            public Object next() {
                return objects[currentIndex++];
            }
        };
    }
}

LinkedList

public class LinkedList_<E> implements Collection_<E>{

    private int size = 0;

    Node<E> first;
    Node<E> last;

    @Override
    public boolean add(E e) {
        Node<E> l = last;
        Node<E> newNode = new Node<>(l,e,null);
        last = newNode;

        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        return true;
    }

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

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public Iterator_ iterator() {
        return new Iterator_() {

            private Node<E> e =  first;

            @Override
            public boolean hasNext() {
                return e!=null && e.item!=null;
            }

            @Override
            public Object next() {
                if (e.next==null){
                    e = null;
                    return last.item;
                }else {
                    e = e.next;
                    return e.prev.item;
                }
            }
        };
    }

    private static class Node<E>{
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element,Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }

    }
}

Main测试

    public static void main(String[] args) {
		
		Collection_<String> list = new LinkedList_<>();
       //Collection_<String> list = new ArrayList_<>();

        System.out.println("是否为空::" + list.isEmpty());

        for (int i = 0; i < 15; i++) {
            list.add("i::" + i);
        }

        System.out.println("是否为空::" + list.isEmpty());
        System.out.println("大小::" + list.size());

        Iterator_ iterator = list.iterator();

        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

结果：