迭代器模式

/**
 * 定义抽象集合类（集聚类）
 * 
 */
public interface MyCollection<E> {
    //提供一个方法产生迭代器
    Iterator<E> iterate ();

}

/**
 * 抽象迭代类
 */
public interface Iterator<E> {
    boolean hasNext();
    E next();
}

/**
 * 简单模拟一下ArrayList,简单写一个get add 方法 具体聚集类
 * @param <E>泛型E
 */
public class MyArrayList<E> implements MyCollection<E> {
    int size;
    Object [] elements;
    int capacity;

    public MyArrayList(int capacity) {
        if(capacity<0){
            throw new RuntimeException("ArrayList的容量必须大于0");
        } else if(capacity==0){
            elements=new Object[]{};
        } else{
            this.capacity = capacity;
            elements=new Object[10];
        }

    }

    public MyArrayList() {
        this(10);
    }
    //add方法
    public boolean add(E e){
        if(size>=capacity){
            int newCapacity=capacity+capacity>>1;
            Arrays.copyOf(elements,newCapacity);
        }
        elements[size++]=e;
        return true;
    }
    //get方法
    public E get(int index){
        if(index>size||index<0){
            throw new RuntimeException("数组下标越界");
        }
        return (E) elements[index];
    }
    //size方法
    public int size(){
        return size;
    }
    @Override
    public Iterator<E> iterate() {
        return new MyArrayListIterator();
    }
    //具体迭代器类
    private class MyArrayListIterator<E> implements Iterator<E> {
        int cursor=0;
        @Override
        public boolean hasNext() {
            if(cursor<size){
                return true;
            }
            return false;
        }

        @Override
        public E next() {
            E e= (E) elements[cursor];
            cursor++;
            return e;

        }
    }
}


/**
 * 为了模拟迭代器模式，自定义LInkedList的add方法,add方法
 */
public class MyLinkedList<E> implements MyCollection<E> {
    private Node<E> first;
    private Node<E> last ;
    int size;

    //add方法
    public boolean add(E e){
        Node<E> n =last;
        Node<E> newNode=new Node<E>(last,null,e);
        last=newNode;
        if(first==null){
            first=newNode;
        }else{
            n.next=newNode;
        }
        size++;
        return true;
    }
    //size方法
    public int size(){
        return size;
    }
    //get方法
    public E get(int index){
       return getNode(index).value;
    }
    //通过下标获取相关的Node节点
    Node<E> getNode(int index){
        if(index>size||index<0){
            throw new RuntimeException("LinkedList下标越界了");
        }
        if(index<(size>>1)){
            Node<E> n= first;
            for(int i=0;i<index;i++){
                n=n.next;
            }
            return n;
        } else{
            Node<E> n= last;
            for (int j=size;j>index;j--){
                n=n.pre;
            }
            return n;
        }

    }
    public MyLinkedList() {

    }

    @Override
    public Iterator<E> iterate() {
        return new LinkedListIterator<>(0);
    }
    private static class Node<E> {
        Node pre;
        Node next;
        E value;

        public Node(Node pre, Node next, E value) {
            this.pre = pre;
            this.next = next;
            this.value = value;
        }
    }
    
/**
*具体聚集类LinkedListIterator
*/
    private class LinkedListIterator<E> implements Iterator<E>{
        public LinkedListIterator(int cursor) {
            this.cursor = cursor;
            currentNode= (Node<E>) getNode(cursor);
        }

        private int cursor;
        Node<E> currentNode;
        @Override
        public boolean hasNext() {
            if(cursor<size){
                return true;
            }
            return false;
        }

        @Override
        public E next() {
            E e =currentNode.value;
            currentNode=currentNode.next;
            cursor++;
            return e;
        }
    }
}

/**
 * 迭代器客户端测试类，迭代器模式，主要用来变量自己的写聚集类（集合类）的元素
 */
public class IteratorClient {
    public static void main(String[] args) {
        MyArrayList<String> myArrayList =new MyArrayList<String>();
        {
            myArrayList.add("jack");
            myArrayList.add("mary");
            myArrayList.add("jerk");

        }
        //获取迭代器
        Iterator<String> iterator =myArrayList.iterate();
        //迭代器集合MyArrayList集合元素
        while(iterator.hasNext()){
            String name=iterator.next();
            System.out.println(name);
        }
        MyLinkedList<String> myLinkedList =new MyLinkedList<String>();
        {
            myLinkedList.add("jack");
            myLinkedList.add(null);
            myLinkedList.add("mary");

        }
        //LinkedList获取迭代器
        Iterator<String> iterator1 =myLinkedList.iterate();
        //迭代器遍历MyLinkedList集合元素
        while(iterator1.hasNext()){
            String name=iterator1.next();
            System.out.println(name);
        }

    }
}