Java Academy · 课时

ListIterator 与双向遍历

Q: 「ListIterator 与双向遍历」这节课中我会学到什么？

使用 ListIterator 向前和向后遍历列表，并在迭代过程中修改元素 你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

使用 ListIterator 向前和向后遍历列表，并在迭代过程中修改元素

ListIterator 与双向遍历 是 CoddyKit 上的免费 Java Academy 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Java Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Java Academy 课程共包含 4 节课。

ListIterator

ListIterator<T> 扩展了 Iterator<T>，支持向后遍历、基于索引的定位，以及在遍历期间添加和替换元素。

ListIterator 接口

除了迭代器之外提供的其他方法：hasPrevious()、previous()、nextIndex()、previousIndex()、set() 和 add()。

import java.util.*;

List<String> list = new ArrayList<>(List.of("A", "B", "C", "D"));
ListIterator<String> lit = list.listIterator();

// Forward traversal
while (lit.hasNext()) {
    System.out.print(lit.nextIndex() + ":" + lit.next() + " ");
}
// 0:A 1:B 2:C 3:D

System.out.println();

// Backward traversal
while (lit.hasPrevious()) {
    System.out.print(lit.previousIndex() + ":" + lit.previous() + " ");
}
// 3:D 2:C 1:B 0:A

从指定位置开始

使用 listIterator(index) 从指定索引处创建 ListIterator。

List<Integer> nums = new ArrayList<>(List.of(10, 20, 30, 40, 50));

// Start at index 2 (30)
ListIterator<Integer> lit = nums.listIterator(2);

System.out.println(lit.next());     // 30
System.out.println(lit.next());     // 40
System.out.println(lit.previous()); // 40
System.out.println(lit.previous()); // 30
System.out.println(lit.previous()); // 20

遍历期间使用 set()

set() 会替换上一次由 next() 或 previous() 返回的元素。此操作效率很高——LinkedList 和 ArrayList 都是 O(1)。

List<String> words = new ArrayList<>(List.of("hello", "world", "java"));
ListIterator<String> lit = words.listIterator();

while (lit.hasNext()) {
    String word = lit.next();
    lit.set(word.toUpperCase()); // replace each with uppercase
}

System.out.println(words); // [HELLO, WORLD, JAVA]

遍历期间使用 add()

add(element) 会在下一个位置之前插入元素。后续调用 next() 不会返回新添加的元素——它已经位于光标的“后方”。

List<Integer> numbers = new ArrayList<>(List.of(1, 2, 3));
ListIterator<Integer> lit = numbers.listIterator();

while (lit.hasNext()) {
    int n = lit.next();
    lit.add(n * 10); // insert n*10 after each element
}

System.out.println(numbers); // [1, 10, 2, 20, 3, 30]

原地反转列表

使用 ListIterator 在 O(n) 时间内反转列表，无需分配新列表。

static <T> void reverse(List<T> list) {
    ListIterator<T> front = list.listIterator(0);
    ListIterator<T> back  = list.listIterator(list.size());

    for (int i = 0, n = list.size() / 2; i < n; i++) {
        T frontVal = front.next();
        T backVal  = back.previous();
        front.set(backVal);
        back.set(frontVal);
    }
}

List<String> data = new ArrayList<>(List.of("a","b","c","d","e"));
reverse(data);
System.out.println(data); // [e, d, c, b, a]

nextIndex 与 previousIndex

nextIndex() 返回调用 next() 时将返回的元素的索引。previousIndex() 返回调用 previous() 时将返回的元素的索引。

List<String> list = List.of("X", "Y", "Z");
ListIterator<String> lit = list.listIterator();

System.out.println(lit.nextIndex());     // 0
System.out.println(lit.previousIndex()); // -1 (before start)

lit.next(); // consume X
System.out.println(lit.nextIndex());     // 1
System.out.println(lit.previousIndex()); // 0

LinkedList 的 ListIterator 性能

LinkedList 的 ListIterator 通过沿指针移动，实现了 O(1) 的 next/previous 操作。对 LinkedList 调用 get(i) 的复杂度是 O(n)，因此应使用 ListIterator 进行高效遍历。

import java.util.*;

LinkedList<Integer> list = new LinkedList<>();
for (int i = 0; i < 5; i++) list.add(i * 10);

// Efficient: O(n) total for traversal via ListIterator
ListIterator<Integer> lit = list.listIterator();
while (lit.hasNext()) {
    int val = lit.next();
    if (val == 20) lit.set(99); // O(1) update
}
System.out.println(list); // [0, 10, 99, 30, 40]

使用 ListIterator 检查回文

这是一个优雅的双向遍历示例：检查列表是否为回文。

static <T> boolean isPalindrome(List<T> list) {
    ListIterator<T> front = list.listIterator(0);
    ListIterator<T> back  = list.listIterator(list.size());

    for (int i = 0, n = list.size() / 2; i < n; i++) {
        if (!front.next().equals(back.previous())) return false;
    }
    return true;
}

System.out.println(isPalindrome(List.of(1, 2, 3, 2, 1))); // true
System.out.println(isPalindrome(List.of(1, 2, 3, 4)));    // false

Iterator 与 ListIterator 对比

主要区别：

迭代器：仅支持向前遍历，提供 hasNext/next/remove
ListIterator：支持双向遍历，提供 hasPrevious/previous、nextIndex/previousIndex、set/add
ListIterator 仅适用于列表（不适用于集合和队列）

使用 ListIterator 实现撤销与重做

使用 ListIterator 实现基于光标的文本编辑器，从而高效地导航字符并执行撤销与重做。

import java.util.*;

class TextEditor {
    private final LinkedList<Character> chars = new LinkedList<>();
    private ListIterator<Character> cursor;

    TextEditor() { cursor = chars.listIterator(); }

    void type(char c) { cursor.add(c); } // insert before cursor

    void moveCursorLeft()  { if (cursor.hasPrevious()) cursor.previous(); }
    void moveCursorRight() { if (cursor.hasNext()) cursor.next(); }

    void backspace() {
        if (cursor.hasPrevious()) { cursor.previous(); cursor.remove(); }
    }

    String text() {
        StringBuilder sb = new StringBuilder();
        chars.forEach(sb::append);
        return sb.toString();
    }
}

TextEditor ed = new TextEditor();
ed.type('H'); ed.type('e'); ed.type('l'); ed.type('o');
ed.moveCursorLeft(); ed.moveCursorLeft();
ed.type('l');
System.out.println(ed.text()); // Hello

何时使用 ListIterator

在以下情况下应使用 ListIterator：

需要向后遍历列表
需要在遍历期间使用 set() 替换元素
需要在遍历期间使用 add() 插入元素
需要通过 nextIndex()/previousIndex() 跟踪位置

快速检查

ListIterator.set() 的作用是什么？

回顾：ListIterator 与双向遍历

要点：

ListIterator 在迭代器的基础上扩展了 hasPrevious()、previous()、set() 和 add()
在指定位置创建 ListIterator：listIterator(index)
set() 会替换上一次由 next() 或 previous() 返回的元素
add() 会在当前光标位置之前插入元素
nextIndex() 和 previousIndex() 提供位置信息
使用 LinkedList 的 ListIterator 可实现 O(1) 的遍历和修改

常见问题解答

「ListIterator 与双向遍历」课时是免费的吗？

是的 — 「ListIterator 与双向遍历」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Java Academy 课程的其余内容，请升级到 CoddyKit PRO。 Java Academy 课程共包含 4 节课。

「ListIterator 与双向遍历」这节课中我会学到什么？

使用 ListIterator 向前和向后遍历列表，并在迭代过程中修改元素你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Java Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Java Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「ListIterator 与双向遍历」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Java Academy 课中编写并运行代码吗？

能。每节 Java Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Java Academy