设计模式-迭代器模式Iterator（行为型）

迭代器模式

迭代器模式属于行为型模式，用来遍历容器的一种模式。

图解

角色

1. 迭代器接口：定义hasNext方法和next方法
2. 具体迭代器：实现hasNext方法和next方法
3. 容器接口：定义返回一个迭代器的接口
4. 具体容器：实现返回迭代器接口

案例

该案例以简单实现ArrayList和LinkedList来演示迭代器模式。整体思想是，不管是什么容器，必须实现获取迭代器的方法，和定义一个迭代器来遍历对应的容器。

public interface Iterable_<E> {
    Iterator_<E> iterator();
}

public interface Collection_<E> extends Iterable_<E>{
    void add(E e);
    int size();
}

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

ArrayList实现类

public class ArrayList_<E> implements Collection_<E>{
    private static final int initSize = 10;
    private Object [] objects = new Object[initSize];
    private int index = 0;

    @Override
    public void add(E e) {
        if(index >= objects.length){
            Object[] newObjects = new Object[(int) (objects.length * 1.5)];
            System.arraycopy(objects,0,newObjects,0,newObjects.length);
            this.objects = newObjects;

        }else {
            objects[index] = e;
        }
        index++;
    }

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

    @Override
    public Iterator_<E> iterator() {
        return new ArrayIterator();
    }
    /** arrayList迭代器*/
    private class ArrayIterator<E> implements Iterator_<E>{
        int cursor;

        @Override
        public boolean hasNest() {
            return cursor != index;
        }
        @Override
        public E next() {
            E e= (E) objects[cursor];
            cursor ++;
            return e;
        }
    }
}

linkedList实现类

public class LinkedList_<E> implements Collection_<E>{
private int size = 0;
private Node<E> lastNode = null;
private Node<E> handNode = null;
@Override
public void add(E e) {
Node<E> objectNode =new Node<>(e,null);
if(lastNode == null){
lastNode = objectNode;
handNode = objectNode;
}else {
lastNode.next = objectNode;
lastNode = objectNode;
}
this.size++;
}
@Override
public int size() {
return size;
}
@Override
public Iterator_<E> iterator() {
return new LinkedIterator();
}
private class LinkedIterator implements Iterator_<E>{
int cursor = 0;
Node<E> tempNode = null;
@Override
public boolean hasNest() {
return cursor != size;
}
@Override
public E next() {
cursor++;
if(cursor ==1){
tempNode = handNode;
return handNode.getValue();
}else {
return tempNode.next.getValue();
}
}
}
private class Node<E>{
private E value;
private Node<E> next;
public Node(E value, Node<E> next) {
this.value = value;
this.next = next;
}
public void setNext(Node<E> next) {
this.next = next;
}
public E getValue() {
return value;
}
}
}

Test类

package com.shaoby.designpatterns.Iterator;
public class Test {
public static void main(String[] args) {
Collection_<String> objectArrayList_ = new LinkedList_<>();
objectArrayList_.add("111");
objectArrayList_.add("222");
objectArrayList_.add("333");
Iterator_<String> iterator = objectArrayList_.iterator();
while (iterator.hasNest()){
System.out.println(iterator.next());
}
}
}