java中的arraylist是基于动态数组实现的集合，支持灵活的增删查改操作。1. 添加元素时，使用add()方法可在末尾或指定索引插入，addall()可批量添加；2. 查询通过get()按索引获取元素，size()获取大小，contains()判断是否包含某元素，isempty()判断是否为空；3. 修改使用set()替换指定位置元素，返回旧值；4. 删除可通过remove(index)按索引或remove(object)按对象删除，clear()清空列表。arraylist相比传统数组更灵活，自动扩容机制使其适用于数据量不确定的场景，但频繁扩容可能影响性能。并发环境下，arraylist非线程安全，可使用collections.synchronizedlist或copyonwritearraylist等替代方案。
Java中的ArrayList，说白了，就是个动态数组。它能让你在编程时，不用像传统数组那样，一开始就得把大小定死。你可以随时往里面加元素，删元素，改元素，甚至查元素，它自己会根据需要自动扩容或缩小。在我看来，这玩意儿是Java集合框架里最常用，也最基础的一个工具，几乎所有需要列表数据结构的地方，你都能看到它的身影。理解它的增删查改，基本上就掌握了Java日常开发中数据操作的一大半。
解决方案
使用ArrayList进行增删查改操作，其实非常直观，API设计得相当人性化。
1. 初始化与添加元素（Add）
立即学习“Java免费学习笔记（深入）”；
创建一个ArrayList很简单，你需要指定它存放的元素类型，这得益于Java的泛型。
import java.util.ArrayList;
import java.util.List; // 通常我们用接口类型声明变量
public class ArrayListDemo {
public static void main(String[] args) {
// 创建一个存放字符串的ArrayList
List<String> names = new ArrayList<>();
// 添加元素到列表末尾
names.add("张三");
names.add("李四");
names.add("王五");
System.out.println("添加后的列表: " + names); // 输出: [张三, 李四, 王五]
// 在指定位置插入元素（索引从0开始）
// 注意：如果索引超出当前列表大小，会抛出IndexOutOfBoundsException
names.add(1, "赵六");
System.out.println("插入后的列表: " + names); // 输出: [张三, 赵六, 李四, 王五]
// 也可以一次性添加另一个集合的所有元素
List<String> moreNames = new ArrayList<>();
moreNames.add("钱七");
moreNames.add("孙八");
names.addAll(moreNames);
System.out.println("批量添加后的列表: " + names); // 输出: [张三, 赵六, 李四, 王五, 钱七, 孙八]
}
}这里要注意，add(index, element) 这个方法，如果你给的 index 大于 size()，或者小于0，那就会直接抛出 IndexOutOfBoundsException。这不像数组，你不能直接跳过中间的索引去赋值。
2. 访问/查询元素（Get/Query）
获取ArrayList中的元素，主要是通过索引来完成。
public class ArrayListDemo {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("张三");
names.add("李四");
names.add("王五");
// 获取指定索引的元素
String firstPerson = names.get(0);
System.out.println("第一个人是: " + firstPerson); // 输出: 第一个人是: 张三
// 获取列表的大小（元素数量）
int size = names.size();
System.out.println("列表大小: " + size); // 输出: 列表大小: 3
// 判断列表是否为空
boolean isEmpty = names.isEmpty();
System.out.println("列表是否为空: " + isEmpty); // 输出: 列表是否为空: false
// 判断列表是否包含某个元素
boolean containsLiSi = names.contains("李四");
System.out.println("是否包含李四: " + containsLiSi); // 输出: 是否包含李四: true
// 遍历列表
System.out.println("遍历列表:");
for (String name : names) {
System.out.println("- " + name);
}
// 或者使用传统的for循环
// for (int i = 0; i < names.size(); i++) {
// System.out.println("- " + names.get(i));
// }
}
}get(index) 同样需要注意索引的边界，超出范围也会抛出 IndexOutOfBoundsException。
3. 修改元素（Set/Update）
如果你想替换ArrayList中某个位置的元素，而不是插入或删除，set() 方法就派上用场了。
public class ArrayListDemo {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("张三");
names.add("李四");
names.add("王五");
System.out.println("原始列表: " + names); // 输出: [张三, 李四, 王五]
// 修改索引1的元素，将"李四"改为"小明"
// set方法会返回被替换掉的旧元素
String oldName = names.set(1, "小明");
System.out.println("修改后的列表: " + names); // 输出: [张三, 小明, 王五]
System.out.println("被替换掉的是: " + oldName); // 输出: 被替换掉的是: 李四
}
}set(index, element) 同样需要确保 index 在合法范围内 [0, size()-1]，否则会抛出 IndexOutOfBoundsException。
4. 删除元素（Remove）
删除操作有两种主要方式：按索引删除和按对象删除。
public class ArrayListDemo {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("张三");
names.add("李四");
names.add("王五");
names.add("李四"); // 再次添加李四，看看按对象删除的效果
System.out.println("原始列表: " + names); // 输出: [张三, 李四, 王五, 李四]
// 按索引删除元素
// 删除索引为2的元素（王五）
String removedByIndex = names.remove(2);
System.out.println("按索引删除后的列表: " + names); // 输出: [张三, 李四, 李四]
System.out.println("按索引删除的是: " + removedByIndex); // 输出: 按索引删除的是: 王五
// 按对象删除元素
// 注意：如果列表中有多个相同的对象，只会删除第一个匹配到的
boolean removedByObject = names.remove("李四");
System.out.println("按对象删除后的列表: " + names); // 输出: [张三, 李四]
System.out.println("是否成功按对象删除: " + removedByObject); // 输出: 是否成功按对象删除: true
// 清空所有元素
names.clear();
System.out.println("清空后的列表: " + names); // 输出: []
System.out.println("清空后列表是否为空: " + names.isEmpty()); // 输出: 清空后列表是否为空: true
}
}remove(index) 也会检查索引合法性。而 remove(Object) 则依赖于对象自身的 equals() 方法来判断是否匹配。如果列表包含 null，你也可以 remove(null) 来删除第一个 null。
ArrayList与传统数组：选择的智慧
很多初学者可能会纠结，既然Java有传统的数组（String[]，int[]），那为什么还需要ArrayList这种东西呢？它们之间最大的区别，也是我们选择时最核心的考量，就在于“灵活性”和“性能”。
AI 舌诊面诊问诊医疗系统 + 诊疗商城系统源码是一套结合 AI 辅助诊断与商品转化的健康类程序，基于浩创云、ThinkPHP（PHP）开发，支持微信服务号与 H5 端，适合做中医舌诊面诊问答、健康建议推送以及配套诊疗商品的运营。
传统数组一旦创建，大小就是固定的，比如你 new String[10]，那它就只能装10个字符串，不多不少。如果你想加第11个，或者删掉一个让数组变小，那就麻烦了，你得新建一个更大或更小的数组，然后把旧数组里的元素一个一个地复制过去。这在数据量不确定或者需要频繁变动的情况下，简直是噩梦。
而ArrayList呢，它骨子里也是基于数组实现的，但它把数组的扩容、缩容这些繁琐的事情都封装起来了。当你的ArrayList快满了，它会自动帮你创建一个更大的内部数组，然后把旧数据复制过去。这就像一个自带“弹性”的容器，你不用操心它的容量问题。
所以，何时选择？
- 如果你明确知道数据的数量，并且这个数量在程序运行过程中不会改变，或者改变非常少，那么传统数组可能更合适。 因为它在内存上更紧凑，访问元素（通过索引）的速度理论上更快一点点，毕竟少了一层封装的开销。
- 但如果你的数据量不确定，或者需要频繁地添加、删除元素，那么ArrayList几乎是你的不二之选。 它的动态性大大简化了代码，提高了开发效率。在绝大多数业务场景下，ArrayList那点因为自动扩容带来的性能开销，相比它带来的便利性，几乎可以忽略不计。当然，如果是在对性能极其敏感，比如百万级甚至千万级数据量的循环操作中，我们可能就需要更深入地考虑数据结构，但那属于另一个层面的优化了。
深入探究：ArrayList的内部扩容机制与性能考量
我们说ArrayList是“动态数组”，那这个“动态”到底是怎么实现的？这背后其实藏着一个巧妙的扩容机制，理解它，能帮助我们更好地优化代码，避免一些潜在的性能陷阱。
ArrayList内部维护着一个普通的Java数组（Object[] elementData），这就是它真正存储元素的地方。当你初始化一个ArrayList但没有指定容量时，它通常会有一个默认的初始容量（比如JDK 8中是10）。
当你在不断地往ArrayList里 add() 元素，直到内部数组装不下的时候，ArrayList就会触发一次“扩容”操作。这个过程大致是这样的：
-
计算新容量： ArrayList会计算一个新的容量，通常是当前容量的1.5倍（
oldCapacity + (oldCapacity >> 1)），或者在某些情况下，如果这个新容量还是不够，就直接取你需要的最小容量。 -
创建新数组： 根据计算出来的新容量，创建一个全新的
Object[]数组。 -
数据复制： 使用
System.arraycopy()方法，将旧数组中的所有元素高效地复制到新数组中。 -
替换引用： 将内部的
elementData引用指向这个新的大数组，旧的数组就等待垃圾回收了。
这个扩容过程对性能的影响主要体现在“数据复制”上。System.arraycopy() 是一个native方法，效率很高，但毕竟涉及到内存的搬迁。如果你的ArrayList频繁地触发扩容，比如你每次只添加一个元素，然后就满了，又扩容，又满了……那么每次扩容都会带来一次O(N)的时间复杂度开销（N是当前元素数量）。这会让一系列看似O(1)的 add() 操作，在某些时刻突然变成O(N)，导致性能出现“尖峰”。
如何优化？ 如果你预估ArrayList将要存储大量元素，或者大致知道元素的最大数量，可以在创建ArrayList时就指定一个合适的初始容量：
// 预估将有1000个元素 List<String> largeList = new ArrayList<>(1000);
这样做可以有效减少扩容的次数，从而避免多次数据复制的开销，提升整体性能。当然，如果你预估的容量过大，而实际只用了很少一部分，那也会造成内存的浪费。所以，这是一个权衡的问题，需要根据实际场景来把握。
另一个方法是，当你知道不会再添加元素，但当前容量远大于实际元素数量时，可以调用 trimToSize() 方法来裁剪内部数组，使其容量与当前元素数量一致，从而释放多余的内存空间。但这通常在列表生命周期即将结束，或者内存特别吃紧时才考虑。
并发考量：ArrayList的线程安全性与替代方案
在多线程环境下使用ArrayList，是个需要特别小心的地方。简单来说，ArrayList本身不是线程安全的。这意味着，如果你有多个线程同时对同一个ArrayList进行修改（比如一个线程在添加，另一个线程在删除），或者一个线程在修改而另一个线程在遍历，很可能会出现数据不一致、丢失数据，甚至抛出 ConcurrentModificationException 这样的运行时异常。
为什么会这样？因为ArrayList的内部操作，比如 add()、remove() 等，都没有进行同步控制。当一个线程正在执行扩容，而另一个线程同时尝试访问或修改，就可能读到不完整的数据，或者破坏了内部数组的结构。ConcurrentModificationException 尤其常见于迭代时修改，因为迭代器通常会检查列表的“修改次数”，一旦发现不一致就会报错。
那么，在并发场景下，我们该如何安全地使用类似ArrayList的功能呢？
-
使用
Collections.synchronizedList()包装： 这是最简单粗暴的方法，它会返回一个线程安全的List。List<String> safeList = Collections.synchronizedList(new ArrayList<>());
这个方法给ArrayList的所有公共方法都加上了
synchronized关键字。但需要注意的是，迭代器仍然不是线程安全的。如果你在迭代safeList的同时，有其他线程修改了它，依然可能抛出ConcurrentModificationException。所以，在迭代时，通常需要手动加锁：synchronized (safeList) { for (String item : safeList) { System.out.println(item); } }这种方式的缺点是，同步粒度较大，所有操作都串行化，在高并发下性能可能会受影响。
-
使用
java.util.concurrent包下的并发集合：CopyOnWriteArrayList这是Java并发包提供的一个专门为并发场景设计的ArrayList替代品。它的特点是：-
读写分离： 在进行修改操作（add, set, remove）时，
CopyOnWriteArrayList会创建一个底层数组的副本，在新副本上进行修改，修改完成后再把引用指向新副本。 - 读操作无锁： 由于写操作是在副本上进行的，读操作可以直接读取旧的（未修改的）数组，因此读操作是完全无锁的，性能很高。
- 适用于读多写少： 这种机制非常适合读操作远多于写操作的场景。
- 缺点： 每次写操作都会复制整个数组，如果列表非常大，或者写操作非常频繁，会带来显著的内存开销和性能损耗。同时，读到的数据可能是“旧”的，即写操作完成前的数据。
import java.util.concurrent.CopyOnWriteArrayList; CopyOnWriteArrayList<String> cowList = new CopyOnWriteArrayList<>(); cowList.add("A"); cowList.add("B"); // 在多线程环境下，读操作很安全，写操作会有副本开销 -
读写分离： 在进行修改操作（add, set, remove）时，
使用
Vector（不推荐）：Vector是ArrayList的“老前辈”，它从一开始就是线程安全的，所有方法都用synchronized修饰。但由于其同步粒度大，性能通常不如ArrayList，而且在现代Java开发中，有了更灵活、性能更好的并发工具，Vector已经很少使用了。
选择哪种方案，取决于你的具体需求：是读多写少，还是写多读少？对实时性要求如何？通常来说，如果只是简单的线程安全需求，Collections.synchronizedList 可以应付；如果读操作非常频繁，CopyOnWriteArrayList 是个不错的选择；而更复杂的并发场景，则可能需要更细粒度的锁控制或者其他并发集合（如 ConcurrentHashMap 等）。
