迭代器模式

迭代器模式

用于遍历的模式

简单实现了 arrayList和LinkedList的add方法，实现Iterator接口实现遍历 加深理解

Code：

import java.util.Arrays;
//测试
public class TestIterator {
    public static void main(String[] args) {
       Collection_ list= new ArrayList_();

        for (int i = 0; i <5; i++) {
            list.add("object: "+ i);
        }
        System.out.println("添加ok!: 元素有:" + list.size()+"个");

        Iterator_ iterator = list.iterator();

        while (iterator.hasNext()){
            Object o = iterator.next();

            System.out.println(o);
        }

    }
}
//迭代器接口
interface Iterator_{
    boolean hasNext();
    Object next();
}
//抽象容器的接口
interface Collection_{
    void add(Object o);
    int size();
    Iterator_ iterator();
}

//可变数组
class ArrayList_ implements Collection_{
    //初始容器大小
    private static int DEFAULT_SIZE = 10;
    //容器
    Object[] objects = new Object[DEFAULT_SIZE];
    //当前的大小
    private int size = 0;
    //iterator 遍历计数器
    private int currentIndex = 0;
    //添加元素
    @Override
    public void add(Object o){
        //如果容器满了的话，扩容原来容器的2倍
        if (size == objects.length){
            Object[] newObjects = Arrays.copyOf(this.objects, this.objects.length * 2);
            objects = newObjects;
        }

        objects[size] = o;

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

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

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

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

}
//链表
class LinkedList_ implements Collection_{
    //保存链表的头部节点
    Node head = null;
    //保存链表的尾部节点
    Node tail = null;
    //容器大小计数器
    private int size = 0;
    //添加元素
    @Override
    public void add(Object o){
        //把object 封装成Node节点
        Node node = new Node(o);
        node.next = null;
        //判断头节点是否为空，
        if (head == null){
            head = node;
            tail = node;
        }
        //将原来最后一个的节点next 指向新添加的节点
        tail.next = node;
        //把尾部节点跟新成新增加的
        tail = node;
        //容量加一
        size++;
    }
    @Override
    public int size(){
        return size;
    }

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

    class LinkedIterator implements Iterator_{
        //当前操作的节点
        private Node currentNode = head;

        @Override
        public boolean hasNext() {
            return currentNode != null;
        }

        @Override
        public Object next() {

            Object object = currentNode.getObject();
            currentNode = currentNode.getNext();
            return object;
        }
    }


    //元素类
    class Node{
        private Object object;
        private Node next;

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

        public Object getObject() {
            return object;
        }

        public void setObject(Object object) {
            this.object = object;
        }

        public Node getNext() {
            return next;
        }

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