17370845950

ArrayList非线程安全，多线程下可用Collections.synchronizedList或CopyOnWriteArrayList；遍历时避免直接修改集合以防ConcurrentModificationException，推荐增强for循环或迭代器遍历，删除操作应使用迭代器remove或倒序遍历。

ArrayList，这个Java集合框架里的“常客”，本质上就是一个动态数组。它提供了一种灵活的方式来存储和操作对象序列，可以根据需要自动扩容，免去了我们手动管理数组大小的麻烦。它的常用操作主要围绕着元素的增、删、改、查，以及一些辅助性的管理方法。

ArrayList的核心操作无非就是围绕着它内部那个可变大小的数组来展开。我们往里塞东西，用

add()

；想看看某个位置有什么，

get()

就派上用场；发现某个元素需要更新，

set()

是正解；要移除一个，

remove()

就行。当然，还有些辅助性的，比如

size()

看看现在有多少个元素，

isEmpty()

判断是不是空，

contains()

查查有没有某个特定元素。理解这些，基本上就掌握了ArrayList的八九不离十。

ArrayList在多线程环境下安全吗？如何避免并发修改异常？

说到ArrayList，我个人在使用中遇到最多的“坑”之一，就是在多线程场景下。ArrayList它本身不是线程安全的，这一点非常关键。这意味着，如果你在多个线程中同时对一个ArrayList进行修改（比如一个线程在添加，另一个线程在删除），或者一个线程在遍历而另一个线程在修改，很大概率会遇到

ConcurrentModificationException

。这并不是说ArrayList的代码写错了，而是它的设计哲学就没考虑并发同步，它更偏向于单线程环境下的高性能。

那么，怎么解决呢？ 一种常见的做法是使用

Collections.synchronizedList()

来包装你的ArrayList：

List synchronizedList = Collections.synchronizedList(new ArrayList<>());
synchronizedList.add("item1");
// ... 其他操作

这种方式会在每次操作时自动加锁，确保了操作的原子性。但它的粒度比较粗，每次操作都锁住整个列表，在高并发场景下可能会成为性能瓶颈。

另一种更“现代”的选择是使用

java.util.concurrent

包下的

CopyOnWriteArrayList

。顾名思义，它在每次修改（添加、删除等）时，都会创建一个底层数组的副本。也就是说，读操作是完全不加锁的，并发性能非常好，因为读写互不影响。但它的缺点也很明显：写操作成本高，因为每次都要复制数组；而且，如果你需要获取最新的数据，可能会有延迟，因为读操作可能还在读取旧的数组副本。所以，

CopyOnWriteArrayList

更适合读多写少的场景。

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.List;

List copyOnWriteList = new CopyOnWriteArrayList<>();
copyOnWriteList.add("itemA");
// 读操作可以并发进行，不会抛异常
for (String item : copyOnWriteList) {
    System.out.println(item);
}

我通常会根据具体的业务场景来选择。如果并发修改不频繁，或者对性能要求没那么极致，

Collections.synchronizedList()

可能就够了。但如果读操作远多于写操作，并且对数据实时性要求不是那么苛刻，

CopyOnWriteArrayList

无疑是更好的选择。

ArrayList与LinkedList、Vector相比，各自的适用场景和性能差异是什么？

这三者都是

List

接口的实现，但底层实现和性能特性却大相径庭，理解它们之间的差异，能帮我们更好地选择合适的工具。

ArrayList：

• 底层实现： 基于动态数组。
• 优点：
  • 随机访问快： 通过索引

    get(index)

    操作非常快，时间复杂度是O(1)，因为可以直接计算出内存地址。
  • 尾部添加快： 在列表末尾添加元素通常也很快，平均时间复杂度是O(1)。
• 缺点：
  • 插入/删除慢： 在列表的中间插入或删除元素时，需要移动后续所有元素，时间复杂度是O(n)。
  • 扩容开销： 当内部数组空间不足时，需要进行扩容，创建一个更大的新数组并将所有元素复制过去，这会带来一定的性能开销。
• 适用场景： 随机访问多，中间插入/删除少，或者只在尾部进行添加操作的场景。

LinkedList：

• 底层实现： 基于双向链表。
• 优点：
  • 插入/删除快： 在列表的任意位置插入或删除元素都非常快，时间复杂度是O(1)，只需要修改前后节点的引用。
• 缺点：
  • 随机访问慢：

    get(index)

    操作需要从头或尾遍历到指定位置，时间复杂度是O(n)。
  • 内存开销： 每个节点都需要额外的空间存储前后节点的引用。
• 适用场景： 频繁进行中间插入/删除操作，或者需要实现队列（Queue）和双端队列（Deque）的场景。

Vector：

• 底层实现： 同样是基于动态数组。
• 优点：
  • 线程安全： Vector的所有公共方法都是同步的（synchronized），因此它是线程安全的。
• 缺点：
  • 性能开销： 因为所有操作都加了同步锁，所以在单线程环境下，它的性能比ArrayList差。
  • 过时： 在Java的并发包（

    java.util.concurrent

    ）出现后，Vector的这种粗粒度同步方式显得有些过时，通常我们有更灵活、更高效的线程安全集合替代方案。
• 适用场景： 很少使用，除非是维护遗留代码。在新的开发中，通常会选择ArrayList配合

  Collections.synchronizedList()

  或

  CopyOnWriteArrayList

  来处理并发需求。

简单来说，如果你需要快速查找，用ArrayList；如果你需要频繁增删，用LinkedList。Vector嘛，现在基本不太推荐用了。

如何高效地遍历ArrayList？有哪些遍历时需要注意的陷阱？

遍历ArrayList，看似简单，实则也有一些门道和陷阱。我通常会根据具体需求和场景来选择遍历方式。

1. 增强for循环 (for-each loop)： 这是我最常用的一种方式，代码简洁，可读性高。

List names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));
for (String name : names) {
    System.out.println(name);
}

优点： 代码简洁，不易出错。 缺点： 无法获取元素的索引；在遍历过程中不能修改集合（会抛

ConcurrentModificationException

）。

2. 传统for循环： 当你需要访问元素的索引时，这种方式是首选。

List names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));
for (int i = 0; i < names.size(); i++) {
    System.out.println("Index " + i + ": " + names.get(i));
}

优点： 可以获取元素的索引；在遍历过程中可以安全地修改集合（但要小心索引的变化）。 缺点： 代码相对不那么简洁；如果

names.get(i)

在一个非ArrayList的List实现上（比如LinkedList），每次

get(i)

都是O(n)操作，会导致整体遍历性能急剧下降到O(n^2)。但对于ArrayList，

get(i)

是O(1)，所以整体遍历是O(n)。

3. 使用Iterator迭代器： 这是Java集合框架推荐的通用遍历方式，也是在遍历过程中安全移除元素的唯一方式。

import java.util.Iterator;
import java.util.ArrayList;
import java.util.List;

List names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie", "David"));
Iterator it = names.iterator();
while (it.hasNext()) {
    String name = it.next();
    System.out.println(name);
    if ("Bob".equals(name)) {
        it.remove(); // 安全移除元素
    }
}
System.out.println("After removal: " + names);

优点： 可以在遍历过程中安全地移除元素（通过

it.remove()

）；适用于所有实现了

Iterable

接口的集合。 陷阱： 如果在遍历过程中，不是通过

Iterator.remove()

而是通过集合本身的

add()

或

remove()

方法修改集合，仍然会抛出

ConcurrentModificationException

。

遍历时的陷阱：

• ConcurrentModificationException

  ： 这是最常见的陷阱。当你在遍历一个集合（无论是用增强for循环还是迭代器）的同时，通过集合自身的

  add()

  、

  remove()

  等方法修改集合结构时，就会抛出这个异常。

  Iterator

  的

  remove()

  方法是唯一的例外，它被设计成可以在遍历时安全地修改集合。

  // 错误示例：会抛出ConcurrentModificationException
  List list = new ArrayList<>(Arrays.asList("A", "B", "C"));
  for (String s : list) {
      if ("B".equals(s)) {
          list.remove(s); // 危险！
      }
  }

• 倒序遍历以安全删除： 如果你必须在传统for循环中删除元素，一种常见的技巧是倒序遍历。

  List list = new ArrayList<>(Arrays.asList("A", "B", "C"));
  for (int i = list.size() - 1; i >= 0; i--) {
      if ("B".equals(list.get(i))) {
          list.remove(i); // 安全！
      }
  }

  这样，即使删除元素，也不会影响到前面已经遍历过的元素的索引。

• 性能考量： 对于ArrayList，传统for循环的

  get(i)

  是O(1)，所以整体遍历是O(n)。增强for循环和迭代器也都是O(n)。所以对于ArrayList来说，性能差异不大，选择哪种主要看代码可读性和是否需要索引或在遍历时修改。但如果换成LinkedList，传统for循环的

  get(i)

  会非常慢，这时就应该优先使用增强for循环或迭代器。

选择合适的遍历方式，不仅能让代码更健壮，也能在特定场景下提升性能。通常我推荐优先使用增强for循环，如果需要索引或在遍历时安全删除，再考虑传统for循环或迭代器。