使用Iterator遍历链表至末尾后，如何将指针移回头部或利用头指针重遍历？

嗨，我来帮你搞定这个问题！你现在用的迭代器遍历完链表后，current指针就走到null了，自然没法再从头开始。这里有两种实用的解决思路，结合你的代码来给你拆解：

方案一：给迭代器添加重置（reset）功能 #

你当前用的是匿名内部类的迭代器，没法直接加方法，所以可以改成具名内部类，专门加一个reset()方法让指针回到头节点。

修改后的完整代码示例 #

import java.util.Iterator;
import java.util.NoSuchElementException;

public class WordLinkedList {
    // 假设你的WordNode是这样的内部类
    private class WordNode {
        String word;
        WordNode next;
        WordNode(String word) {
            this.word = word;
            this.next = null;
        }
    }

    private WordNode first; // 链表头指针

    // 改成具名内部类的迭代器，支持重置
    private class WordIterator implements Iterator<String> {
        private WordNode current;

        public WordIterator() {
            this.current = first; // 初始化时指向头节点
        }

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

        @Override
        public String next() {
            if (!hasNext()) {
                throw new NoSuchElementException("已经到链表末尾啦");
            }
            String result = current.word;
            current = current.next; // 补全你代码里的指针移动逻辑
            return result;
        }

        // 新增重置方法，把指针移回头节点
        public void reset() {
            this.current = first;
        }
    }

    // 重写iterator方法返回自定义迭代器
    @Override
    public Iterator<String> iterator() {
        return new WordIterator();
    }

    // 可选：添加元素的方法，方便测试
    public void add(String word) {
        WordNode newNode = new WordNode(word);
        if (first == null) {
            first = newNode;
        } else {
            WordNode temp = first;
            while (temp.next != null) {
                temp = temp.next;
            }
            temp.next = newNode;
        }
    }
}

使用方式 #

当你遍历完一次后，把迭代器强转成自定义的WordIterator，调用reset()就能重新从头遍历：

public class Main {
    public static void main(String[] args) {
        WordLinkedList list = new WordLinkedList();
        list.add("Hello");
        list.add("World");
        list.add("Java");

        WordIterator iterator = (WordIterator) list.iterator();

        // 第一次遍历
        System.out.println("第一次遍历：");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // 重置后第二次遍历
        iterator.reset();
        System.out.println("\n第二次遍历：");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

方案二：每次遍历都生成新的迭代器 #

这其实就是利用你提到的头指针来实现的——因为每次调用iterator()方法时，新迭代器的current都会重新指向头节点first，天然就能从头开始遍历。这种方式更符合Java迭代器的常规设计（标准迭代器本来就是一次性的，每次遍历生成新实例），代码也更简洁。

使用示例 #

public class Main {
    public static void main(String[] args) {
        WordLinkedList list = new WordLinkedList();
        list.add("Hello");
        list.add("World");
        list.add("Java");

        // 第一次遍历（用增强for循环，底层会自动获取新迭代器）
        System.out.println("第一次遍历：");
        for (String word : list) {
            System.out.println(word);
        }

        // 第二次遍历，直接重新获取迭代器
        System.out.println("\n第二次遍历：");
        Iterator<String> newIterator = list.iterator();
        while (newIterator.hasNext()) {
            System.out.println(newIterator.next());
        }
    }
}

两种方案的选择建议 #

• 如果需要在同一个迭代器实例上中途暂停、重置后继续遍历，选方案一；
• 如果只是需要多次完整遍历链表，方案二更简单，也更符合Java的编码习惯。

内容的提问来源于stack exchange，提问作者poppyd