Java ListIterator接口详解：双向遍历与列表修改技巧

1. ListIterator 接口概述

ListIterator 是 Java 集合框架中一个强大的双向遍历工具，它扩展了普通 Iterator 的功能，允许开发者在列表中进行前后双向移动、修改元素以及获取元素位置等操作。这个接口在需要精细控制列表遍历的场景下特别有用，比如需要在遍历过程中动态修改列表内容时。

与普通 Iterator 相比，ListIterator 提供了更丰富的操作方法。它不仅支持 hasNext() 和 next() 这样的基本遍历方法，还额外提供了 hasPrevious() 和 previous() 方法实现反向遍历。更重要的是，它允许通过 set() 方法替换当前元素，通过 add() 方法在当前位置插入新元素，这在某些算法实现中非常关键。

在实际开发中，ListIterator 常用于以下场景：

• 需要双向遍历列表的情况
• 遍历过程中需要修改列表内容
• 需要知道当前遍历位置的索引
• 实现某些特定算法时（如列表的部分反转、元素替换等）

提示：虽然 ArrayList 和 LinkedList 都支持 ListIterator，但在 LinkedList 上使用它的性能优势更明显，因为 LinkedList 本身就是双向链表结构。

2. ListIterator 核心方法详解

2.1 基本遍历方法

ListIterator 提供了两组遍历方法，分别用于正向和反向遍历：

java复制// 正向遍历方法
boolean hasNext();  // 判断是否还有下一个元素
E next();           // 返回下一个元素并将光标前移

// 反向遍历方法
boolean hasPrevious();  // 判断是否还有前一个元素
E previous();           // 返回前一个元素并将光标后移

这些方法的使用模式与普通 Iterator 类似，但增加了反向遍历的能力。一个典型的使用示例如下：

java复制List<String> list = Arrays.asList("A", "B", "C", "D");
ListIterator<String> it = list.listIterator();

// 正向遍历
while(it.hasNext()) {
    System.out.println(it.next());
}

// 反向遍历
while(it.hasPrevious()) {
    System.out.println(it.previous());
}

2.2 修改操作方法

ListIterator 最强大的特性之一是允许在遍历过程中修改列表内容：

java复制void add(E e);      // 在当前位置插入元素
void set(E e);      // 替换最后一次访问的元素

add() 方法会在当前迭代器位置（即 next() 将返回的元素之前和 previous() 将返回的元素之后）插入指定元素。set() 方法则替换最后一次调用 next() 或 previous() 返回的元素。

注意：必须在调用 next() 或 previous() 后才能调用 set() 或 add()，否则会抛出 IllegalStateException。

2.3 位置查询方法

ListIterator 还提供了查询当前位置的方法：

java复制int nextIndex();     // 返回下一次调用next()将返回的元素的索引
int previousIndex(); // 返回下一次调用previous()将返回的元素的索引

这些方法在需要知道当前遍历位置的算法中非常有用，比如实现部分列表反转或特定位置插入等操作。

3. ListIterator 与普通 Iterator 的对比

3.1 功能对比

3.2 性能考虑

在 ArrayList 上，ListIterator 的性能与普通 Iterator 相当，因为 ArrayList 的随机访问特性使得双向遍历没有额外开销。但在 LinkedList 上，ListIterator 的性能优势更明显，因为它能充分利用 LinkedList 的双向链表结构。

一个常见的性能优化技巧是：如果需要频繁反向遍历，使用 LinkedList 配合 ListIterator 会比使用 ArrayList 更高效。

3.3 使用场景选择

选择使用 Iterator 还是 ListIterator 主要取决于需求：

• 只需要简单正向遍历 → Iterator
• 需要双向遍历或修改元素 → ListIterator
• 需要从中间位置开始遍历 → ListIterator
• 需要知道当前位置索引 → ListIterator

4. 实战应用与常见问题

4.1 列表元素替换模式

ListIterator 特别适合需要在遍历过程中替换元素的情况。下面是一个将所有空字符串替换为 "(空)" 的示例：

java复制List<String> list = new ArrayList<>(Arrays.asList("A", "", "B", "", "C"));
ListIterator<String> it = list.listIterator();

while(it.hasNext()) {
    String element = it.next();
    if(element.isEmpty()) {
        it.set("(空)");
    }
}

这种模式比先遍历找到位置再单独修改更高效，尤其对于 LinkedList 这样的结构。

4.2 列表元素插入技巧

使用 add() 方法可以在遍历过程中动态插入元素。例如，在特定条件下插入分隔符：

java复制List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));
ListIterator<String> it = list.listIterator();

while(it.hasNext()) {
    String element = it.next();
    if(element.equals("B")) {
        it.add("分隔符");
    }
}
// 结果列表为 [A, B, 分隔符, C, D]

4.3 常见错误与解决方案

错误1：未调用 next() 或 previous() 就直接调用 set()

java复制ListIterator<String> it = list.listIterator();
it.set("X");  // 抛出 IllegalStateException

解决方案：确保在调用 set() 前至少调用过一次 next() 或 previous()。

错误2：并发修改问题

java复制List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
ListIterator<String> it = list.listIterator();
list.add("D");  // 直接修改原列表
it.next();      // 可能抛出 ConcurrentModificationException

解决方案：避免在使用迭代器时直接修改原列表，应该通过迭代器的方法进行修改。

错误3：无限循环

java复制while(it.hasNext()) {
    it.add("X");  // 每次添加都会增加新元素，导致无限循环
}

解决方案：注意 add() 操作会影响 hasNext() 的判断，需要设计合理的终止条件。

5. 高级应用场景

5.1 列表部分反转实现

利用 ListIterator 可以高效实现列表的部分反转：

java复制public static <T> void reverseSubList(List<T> list, int from, int to) {
    ListIterator<T> fwd = list.listIterator(from);
    ListIterator<T> rev = list.listIterator(to);
    
    for(int i=0, mid=(to-from)/2; i<mid; i++) {
        T temp = fwd.next();
        fwd.set(rev.previous());
        rev.set(temp);
    }
}

这个方法比使用 subList() 和 Collections.reverse() 的组合更高效，特别是对于 LinkedList。

5.2 列表合并模式

使用 ListIterator 可以实现复杂的列表合并逻辑：

java复制public static <T extends Comparable<T>> void mergeSortedLists(
        List<T> list1, List<T> list2, List<T> output) {
    
    ListIterator<T> it1 = list1.listIterator();
    ListIterator<T> it2 = list2.listIterator();
    
    while(it1.hasNext() && it2.hasNext()) {
        T e1 = it1.next();
        T e2 = it2.next();
        
        if(e1.compareTo(e2) <= 0) {
            output.add(e1);
            it2.previous();  // 回退it2
        } else {
            output.add(e2);
            it1.previous();  // 回退it1
        }
    }
    
    // 添加剩余元素
    while(it1.hasNext()) output.add(it1.next());
    while(it2.hasNext()) output.add(it2.next());
}

5.3 实现自定义过滤器

ListIterator 可以用来实现原地(in-place)列表过滤：

java复制public static <T> void filter(List<T> list, Predicate<T> predicate) {
    ListIterator<T> it = list.listIterator();
    while(it.hasNext()) {
        if(!predicate.test(it.next())) {
            it.remove();
        }
    }
}

这种方法比创建新列表更节省内存，特别是处理大型列表时。

6. 性能优化与最佳实践

6.1 初始化位置优化

ListIterator 可以从任意位置开始遍历，这在处理大型列表的部分数据时非常有用：

java复制// 直接从中间位置开始遍历
ListIterator<String> it = list.listIterator(list.size()/2);

对于 LinkedList，这种优化可以显著减少遍历时间，因为不需要从头开始逐个移动。

6.2 批量操作模式

当需要连续修改多个元素时，使用单个 ListIterator 比多次获取迭代器更高效：

java复制// 不推荐 - 多次获取迭代器
for(int i=0; i<list.size(); i++) {
    if(condition) {
        ListIterator<String> it = list.listIterator(i);
        it.next();
        it.set("new");
    }
}

// 推荐 - 单次迭代器完成所有修改
ListIterator<String> it = list.listIterator();
while(it.hasNext()) {
    if(condition) {
        it.set("new");
    }
    it.next();
}

6.3 线程安全考虑

ListIterator 不是线程安全的。在多线程环境下使用时，需要采取适当的同步措施：

java复制List<String> list = Collections.synchronizedList(new ArrayList<>());

// 必须同步整个迭代过程
synchronized(list) {
    ListIterator<String> it = list.listIterator();
    while(it.hasNext()) {
        // 操作代码
    }
}

或者考虑使用并发集合类如 CopyOnWriteArrayList，但需要注意它们的迭代器是快照迭代器，不反映迭代后的修改。

7. 与其他Java特性的结合使用

7.1 与泛型的结合

ListIterator 完全支持泛型，可以避免类型转换：

java复制List<String> list = new ArrayList<>();
ListIterator<String> it = list.listIterator();
String element = it.next();  // 不需要强制类型转换

7.2 与Lambda表达式结合

Java 8 之后，可以结合 Lambda 表达式使用 ListIterator 实现更简洁的代码：

java复制List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
list.listIterator().forEachRemaining(e -> {
    if(e.equals("B")) {
        // 操作代码
    }
});

7.3 与Stream API对比

虽然 Stream API 提供了强大的集合操作能力，但在需要修改原列表或双向遍历时，ListIterator 仍是更好的选择：

选择依据：

• 需要修改原列表 → ListIterator
• 需要复杂函数式操作 → Stream API
• 需要双向遍历或位置感知 → ListIterator
• 需要并行处理 → Stream API

在实际项目中，我经常结合使用这两种技术，根据具体需求选择最合适的工具。对于简单的遍历修改，ListIterator 更直接高效；对于复杂的数据转换和过滤，Stream API 则更加优雅强大。