Java数据结构与算法笔记——实现带迭代器的链表

迭代器

Iterator：迭代器，它是Java集合的顶层接口（不包括map系列的集合）。

主要方法：

• Object next()： 返回迭代器刚越过的元素的引用，返回值是Object，需要强制转化为自己需要的类型
• boolean hasNext()： 判断容器内是否还有可供访问的元素
• void remove()： 删除迭代器刚越过的元素

所以除了map系列的集合，我们都能通过迭代器对集合中的元素进行遍历。

具有迭代器的单链表

让链表本身实现迭代功能，代替我们用循环遍历链表里的所有节点数据。

定义接口

定义ListInterface接口，指定单链表中的各种操作：

package iterator;

/**
 * 定义接口
 * @param <T>
 */
// 接口是一种规范，没有具体实现，但是规定了应该怎么实现
public interface ListInterface<T> {  // 规定了链表应该怎么实现哪些基本功能
    // 返回当前的链表的节点个数
    public int getSize();

    // 实现在链表头部添加新节点
    public void addHeader(T data);

    // 实现在链表尾部添加新节点
    public void addTail(T data);

    // 实现删除链头部元素
    public T deleteHead();

}

扩展接口

定义ListWithIteratorInterface接口，在ListInterface接口的基础上添加迭代器方法

package iterator;

import java.util.Iterator;

/**
 * 继承接口类，添加新方法
 * @param <T>
 */
public interface ListWithIteratorInterface<T> extends ListInterface<T> { //继承接口

    // 获取迭代器的方法
    public Iterator<T> getIterator();

}

实现接口

定义LinkListWithIterator实现LinkListWithIterator接口（相当于ADT的实现类）。

LinkListWithIterator中定义了一个内部类：IteratorForLinkedList，该内部类implements Iterator。

package iterator;

import java.util.Iterator;

/**
 * 实现接口
 * @param <T>
 */
// LinkListWithIterator是一个链表的封装类
public class LinkListWithIterator<T> implements ListWithIteratorInterface<T> {

    private Node head;
    private Node tail;
    private int size;

    private class Node{
        private T data; //T：泛型
        private Node next;

        //构造方法，初始化节点
        public Node(T data){
            this.data = data;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "data=" + data +
                    ", next=" + next +
                    '}';
        }
    }


    /**实现Iterator接口
     *
     */
    // 以内部类的形式定义迭代器
    private class IteratorForLinkedList implements Iterator<T>{

        private Node nextNode; // 下一个节点的引用

        // 构造方法
        public IteratorForLinkedList(){
            nextNode = head;
        }

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

        @Override
        public T next() {
            if(hasNext()){
                Node rs = nextNode; // 保存一下
                nextNode = nextNode.next; //移动指针
                return rs.data;
            }else {
                return null;
            }
        }
    }


    /**
     * 重写定义的接口中的方法
     */
    @Override
    public Iterator<T> getIterator() {
        return new IteratorForLinkedList();
    }

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

    @Override
    public void addHeader(T data) {
        Node newNode = new Node(data);
        if(size == 0){
            head = newNode;
            tail = newNode;
        }else {
            newNode.next = head;
            head = newNode;
        }
        size ++;
    }

    @Override
    public void addTail(T data) {
        Node newNode = new Node(data);
        if(size ==0){
            head = newNode;
            tail=newNode;
            size++;
        }else {
            tail.next = newNode;
            tail = newNode;
            size++;
        }
    }

    @Override
    public T deleteHead() {
        Node temp = new Node(null);
        if (size != 0) {
            temp = head;
            head = head.next;
        }
        return temp.data;
    }
}

测试接口

package iterator;

import java.util.Iterator;

/** 测试程序
 *
 */
public class IteratorLinkTest {
    public static void main(String[] args) {
        LinkListWithIterator<Integer> link = new LinkListWithIterator<>();
        link.addHeader(1);
        link.addHeader(2);
        link.addHeader(3);

        link.addTail(4);
        link.addTail(5);
        System.out.println("size:"+Integer.toString(link.getSize()));

        Iterator<Integer> iterator = link.getIterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println("-------------------------------------------------");
        System.out.println(link.deleteHead());
        System.out.println("-------------------------------------------------");
        Iterator<Integer> iterator1 = link.getIterator();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());
        }
    }
}