【Java数据结构】2.3双向链表的迭代实现

上一章  双向链表的简单实现，本章介绍迭代实现模式    

使用迭代模式的优点：
          1，实现功能分离，简化容器接口。让容器只实现本身的基本功能，把迭代功能委让给外部类实现，符合类的设计原则。
          2，隐藏容器的实现细节。
          3，为容器或其子容器提供了一个统一接口，一方面方便调用；另一方面使得调用者不必关注迭代器的实现细节。
          4，可以为容器或其子容器实现不同的迭代方法或多个迭代方法。
   我觉得第4点说的很好，对于一堆数据而言，不同的人（或业务逻辑）使用它的方式也不尽相同，定义一个theIterator继承Iterator，不仅提供next，hasNext 以及remove这个最小的操作集合，同时也可以提供更多的其它方法。在theIterator的实现类中，具体实现不同的迭代方法，比如顺序、逆序或根据其它语义进行遍历等，再通过类厂的方式将一个theIterator实现的对象交给用户使用。

迭代模式实现：

package com.ds.link;
import java.util.Iterator;
import java.util.NoSuchElementException;
public class DoubleLinkIt<T> implements Iterable<T> {
    /**
     * Node<AnyType>类定义了双向链表中节点的结构，它是一个私有类，
     * 而其属性和构造函数都是公有的，这样，其父类可以直接访问其属性
     * 而外部类根本不知道Node类的存在。
     * @author ZHB
     *
     * @param <T> 类型
     * @param Data 是节点中的数据
     * @param pre  指向前一个Node节点
     * @param next 指向后一个Node节点
     */
    private class Node<T> {
        public Node<T> pre;
        public Node<T> next;
        public T data;
        public Node(T data, Node<T> pre, Node<T> next) {
            this.data = data;
            this.pre = pre;
            this.next = next;
        }
        public Node() {
            this.data = null;
            this.pre = null;
            this.next = null;
        }
    }
    // 下面是DoubleLinkedList类的数据成员和方法
    private int theSize;
    private Node<T> Header;
    private Node<T> Tail;
    /*
     * 构造函数
     * 我们构造了一个带有头、尾节点的双向链表
     * 头节点的Next指向尾节点
     * 为节点的pre指向头节点
     * 链表长度起始为0。
     */
    public DoubleLinkIt() {
        theSize = 0;
        Header = new Node<T>(null, null, null);
        Tail = new Node<T>(null, Header, null);
        Header.next = Tail;
    }
    public void add(T item) {
        Node<T> aNode = new Node<T>(item, null, null);
        Tail.pre.next = aNode;
        aNode.pre = Tail.pre;
        aNode.next = Tail;
        Tail.pre = aNode;
        theSize++;
    }
    public boolean isEmpty() {
        return (this.theSize == 0);
    }
    public int size() {
        return this.theSize;
    }
    public T getInt(int index) {
        if (index > this.theSize - 1 || index < 0)
            throw new IndexOutOfBoundsException();
        Node<T> current = Header.next;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        return current.data;
    }
    public void print() {
        Node<T> current = Header.next;
        while (current.next != null) {
            System.out.println(current.data.toString());
            current = current.next;
        }
    }
    /*
     *
     * DoubleLinkIt类实现了java.lan.Itrable接口，
     * 因此我们必须实现其public Iterator<Type> iterator() {}方法，它的返回值是一个迭代器对象，
     * 那么我就定义一个内部私有类――MyListIterator，这个类实现了iterator接口。
     * 在public Iterator<Type> iterator() 方法中，我就构造这么一个MyListIterator的对象并返回。
     *Iterator接口有三个方法是我们必须实现的，hasNext，next和remove，
     *这是迭代操作的最小集合了。对于不同的迭代器执行方式，
     *我们可以定义多个类似MyListIterator这样的实现类，只要在链表类中的iterator() 方法中把具体实现类的对象返回给用户就OK了。
     */
    @Override
    public Iterator<T> iterator() {
        return new myListIterator();
    }
    public class myListIterator implements Iterator<T> {
        Node<T> current = Header.next;
        @Override
        public boolean hasNext() {
            return (current != Tail);
        }
        @Override
        public T next() {
            if (!hasNext())
                throw new IndexOutOfBoundsException();
            T item = current.data;
            current = current.next;
            return item;
        }
        @Override
        public void remove() {
            if (!hasNext())
                throw new NoSuchElementException();
            current.pre.next = current.next;
            current.next.pre = current.pre;
            current = current.next;
            theSize--;
        }
    }
    //测试代码
    public static void main(String[] args) {
        DoubleLinkIt<ItemInfo> itLink = new DoubleLinkIt<ItemInfo>();
        for (int i = 0; i < 10; i++) {
            ItemInfo item = new ItemInfo(" " + i, i * i);
            itLink.add(item);
        }
        Iterator<ItemInfo> it = itLink.iterator();
      //  while (it.hasNext())
      //      it.remove();
        while (it.hasNext())
            System.out.println(it.next().toString());
    }
}

其中 ItemInfo的定义如下：

package com.ds.link;
public class ItemInfo {
    private String name;
    private int age;
                                         
    public ItemInfo(String name,int age){
        this.name = name;
        this.age = age;
    }
                                         
    public ItemInfo(){
        this.name = null;
        this.age = 0;
    }
                                         
    public String toString(){
        StringBuilder sb = new StringBuilder("姓名：");
        sb.append(this.name).append("\t").append("年龄:").append(this.age);
                                             
        return sb.toString();
    }
}

运行结果：

姓名： 0   年龄:0
姓名： 1   年龄:1
姓名： 2   年龄:4
姓名： 3   年龄:9
姓名： 4   年龄:16
姓名： 5   年龄:25
姓名： 6   年龄:36
姓名： 7   年龄:49
姓名： 8   年龄:64
姓名： 9   年龄:81

如果存在问题，我们随时沟通！