当前位置：首页 > 文章列表 > 文章 > java教程 > ArrayList常用操作方法详解

ArrayList常用操作方法详解

2025-10-04 14:01:55 0浏览收藏

在文章实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《ArrayList常用操作方法大全》，聊聊，希望可以帮助到正在努力赚钱的你。

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

ArrayList常用操作方法详解

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

ArrayList的核心操作无非就是围绕着它内部那个可变大小的数组来展开。我们往里塞东西，用add()；想看看某个位置有什么，get()就派上用场；发现某个元素需要更新，set()是正解；要移除一个，remove()就行。当然，还有些辅助性的，比如size()看看现在有多少个元素，isEmpty()判断是不是空，contains()查查有没有某个特定元素。理解这些，基本上就掌握了ArrayList的八九不离十。

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

说到ArrayList，我个人在使用中遇到最多的“坑”之一，就是在多线程场景下。ArrayList它本身不是线程安全的，这一点非常关键。这意味着，如果你在多个线程中同时对一个ArrayList进行修改（比如一个线程在添加，另一个线程在删除），或者一个线程在遍历而另一个线程在修改，很大概率会遇到ConcurrentModificationException。这并不是说ArrayList的代码写错了，而是它的设计哲学就没考虑并发同步，它更偏向于单线程环境下的高性能。

那么，怎么解决呢？一种常见的做法是使用Collections.synchronizedList()来包装你的ArrayList：

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

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

另一种更“现代”的选择是使用java.util.concurrent包下的CopyOnWriteArrayList。顾名思义，它在每次修改（添加、删除等）时，都会创建一个底层数组的副本。也就是说，读操作是完全不加锁的，并发性能非常好，因为读写互不影响。但它的缺点也很明显：写操作成本高，因为每次都要复制数组；而且，如果你需要获取最新的数据，可能会有延迟，因为读操作可能还在读取旧的数组副本。所以，CopyOnWriteArrayList更适合读多写少的场景。

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

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

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

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

List<String> 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<String> names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie", "David"));
Iterator<String> 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<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
for (String s : list) {
    if ("B".equals(s)) {
        list.remove(s); // 危险！
    }
}
```
倒序遍历以安全删除： 如果你必须在传统for循环中删除元素，一种常见的技巧是倒序遍历。
```
List<String> 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循环或迭代器。