四、迭代器模式Iterator（行为型模式）

迭代器模式为顺序访问集合对象的元素提供一种方式，且不暴露其底层表示法。

就数据结构而言，它们把复杂的浏览途径部分委托给Iterator类别。让其数据结构能与各式各样的Iterator类别搭配，而且分和自如。因而Iterator类别包容了数据结构（如ArrayList和Database）的多变性，非常有助于软件的新陈代谢。

容器接口：

interface Collection {
   void add(Object o);
   int size();
   Iterator iterator();
}

迭代器接口：

interface Iterator {

   Object next();
   boolean hasNext();
}

线性表的链式存储结构

class LinkedList implements Collection {

   Node head;

   Node tail;

   int size;

   private class Node {

      Object data;

      Node next;

      public Node(Object data, Node next) {

        super();

        this.data = data;

        this.next = next;

      }

      public Object getData() {

        return data;

      }

      public void setData(Object data) {

        this.data = data;

      }

      public Node getNext() {

        return next;

      }

      public void setNext(Node next) {

        this.next = next;

      }

   }

   public void add(Object o) {

      Node n = new Node(o, null);

      if (head == null) {

        head = n;

        tail = n;

      }

      tail.setNext(n);

      tail = n;

      size++;
   }

   public int size() {

      return size;

   }


   @Override

   public Iterator iterator() {

      return new LinkedListIterator();

   }

   
}

链表的迭代器：

private class LinkedListIterator implements Iterator {

      Node node = head;

      @Override

      public Object next() {

        Node tmp = node;

        node = node.next;

        return tmp;
      }

      @Override

      public boolean hasNext() {

        return node != null;
      }
   }

线性表的顺序存储结构：

class ArrayList implements Collection {

   Object[] os = new Object[10];

   int index = 0;

   public void add(Object o) {

      if (index == os.length) {

        Object[] newOs = new Object[os.length * 2];

        System.arraycopy(os, 0, newOs, 0, os.length);

        os = newOs;

      }

      os[index] = o;

      index++;

   }

   public int size() {

      return index;

   }

 

   public Iterator iterator() {

      return new ArrayListIterator();

   }

   private class ArrayListIterator implements Iterator {

      private int currentIndex = 0;

      @Override

      public Object next() {

        return os[currentIndex++];

      }

      @Override

      public boolean hasNext() {

        return currentIndex < index;

      }
   }
}

支持泛形：

class GenericArrayList<E> {

   Object[] os = new Object[10];

   int index = 0;

   public void add(E o) {

      if (index == os.length) {

        Object[] newOs = new Object[os.length * 2];

        System.arraycopy(os, 0, newOs, 0, os.length);

        os = newOs;

      }

      os[index] = o;

      index++;

   }

   public int size() {

      return index;
   }

}

测试：

package interator;

 

public class Test1 {

   public static void main(String[] args) {

      // ArrayList al = new ArrayList();

      LinkedList al = new LinkedList();

      // Collection al = new ArrayList();

      for (int i = 0; i < 15; i++) {

        al.add(new Object());

      }

      System.out.println(al.size());

      // ------------遍历----------------

      /*

       * ArrayList a = (ArrayList) al; for (int i = 0; i < a.index; i++) { //

       * ...... }

       */

      // -----------

      Iterator it = al.iterator();

      while (it.hasNext()) {

        Object o = it.next();

        System.out.println(o);

      }

      System.out.println("dasdsadsa");

      // --------泛型

      GenericArrayList<String> ga = new GenericArrayList<>();

      ga.add("sss");

   }

}