实现链表的迭代器Java

简介

链表是一种常见的数据结构，但遍历链表时常常需要使用循环语句。为了提高代码的可读性和灵活性，可以使用迭代器模式实现链表的遍历。

本文将介绍如何通过迭代器模式实现链表的迭代器。

迭代器模式

迭代器模式是一种行为型设计模式，它可以将集合对象的访问与遍历分离开来，从而使得遍历算法能够独立于集合对象而变化。

迭代器模式一般包含以下几个角色：

• 迭代器：定义遍历集合的接口，包含 hasNext() 和 next() 方法；
• 具体迭代器：实现迭代器接口，负责遍历集合中的元素；
• 集合：定义存储元素的接口，包含 getIterator() 方法；
• 具体集合：实现集合接口，提供创建迭代器的方法。

实现链表的迭代器

以下是实现链表的迭代器的关键代码片段：

public class LinkedList<E> implements Iterable<E> {

    private Node<E> head;
    private int size;

    public LinkedList() {
        head = null;
        size = 0;
    }

    @Override
    public Iterator<E> iterator() {
        return new LinkedListIterator<E>(head);
    }

    private static class LinkedListIterator<E> implements Iterator<E> {

        private Node<E> current;

        public LinkedListIterator(Node<E> head) {
            current = head;
        }

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

        @Override
        public E next() {
            E element = current.element;
            current = current.next;
            return element;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }

    private static class Node<E> {
        E element;
        Node<E> next;

        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }
    }
}

在上述代码中，我们定义了一个 LinkedList 类，并实现了 Iterable 接口，该接口定义了 iterator() 方法，该方法返回一个迭代器对象。

我们还定义了一个 LinkedListIterator 类，它实现了 Iterator 接口。在构造方法中，我们将头结点作为参数传入，将 current 指针指向头结点。

在 hasNext() 方法中，我们判断 current 是否为 null，以判断是否到达链表末尾。

在 next() 方法中，我们先获取当前节点的元素值，再将 current 指针后移一位，以便下次遍历。

在 remove() 方法中，我们直接抛出一个 UnsupportedOperationException 异常，因为链表一般不支持删除操作。

使用示例

以下是使用链表迭代器的示例：

LinkedList<Integer> list = new LinkedList<Integer>();
list.add(1);
list.add(2);
list.add(3);

for (Integer n : list) {
    System.out.print(n + " ");
}
// Output: 1 2 3

在上述代码中，我们创建了一个链表对象 list，并添加了三个元素。然后通过 for-each 循环遍历链表，输出其元素。

总结

通过实现迭代器模式，可以使得遍历链表的代码更加简洁、易读，并可以灵活地改变遍历算法。