前言：ArrayList是Java中最常用的动态数组实现之一，它提供了便捷的操作接口和灵活的扩展能力，使得在处理动态数据集合时非常方便。本文将深入探讨Java中ArrayList的实现原理、常用操作以及一些使用场景。
✨✨✨这里是秋刀鱼不做梦的BLOG
✨✨✨想要了解更多内容可以访问我的主页秋刀鱼不做梦-CSDN博客
在文章开始之前，先让我们看一下本文的大致内容：
目录
1.认识ArrayList
2.ArrayList的创建
（1）使用默认构造函数创建一个空的 ArrayList：
（2）使用带有初始容量的构造函数创建 ArrayList：
（3）使用 ArrayList(Collection c) 构造函数创建 ArrayList 的简单示例：
3.ArrayList的遍历
遍历ArrayList的方式：
（1）使用for循环
（2）使用增强型for循环：
（3）使用迭代器
4.ArrayList常用API
（1）boolean add(E e)——尾插 e
（2）void add(int index, E element)——将 e 插入到 index 位置
（3）boolean addAll(Collection c)——尾插 c 中的元素
（4）E remove(int index)——删除 index 位置元素
（5）boolean remove(Object o)——删除遇到的第一个 o
（6）E get(int index)——获取下标 index 位置元素
（7）E set(int index, E element)——将下标 index 位置元素设置为 element
（8）void clear()——清空
（9）boolean contains(Object o)——判断 o 是否在线性表中
（10）int indexOf(Object o)——返回第一个 o 所在下标
（11）int lastIndexOf(Object o)——返回最后一个 o 的下标
（12）List subList(int fromIndex, int toIndex)——截取部分 list
1.认识ArrayList
在正式的学习ArrayList之前，我们需要了解一下什么是Java中的ArrayList（顺序表）：
ArrayList是Java中的一个动态数组类，它实现了List接口，可以存储任意类型的对象，并且大小可以动态地调整。ArrayList允许在列表的任意位置进行元素的插入、删除、获取等操作，而且它还能自动扩展内部数组的容量，以适应存储需求的增长。
ArrayList是一个普通的类，实现了List接口，具体框架图如下：
读到这就会有读者发问了，ArrayList到底是怎么去实现这些功能的呢？，它的底层原理到底是怎么样的呢？答案如下：
ArrayList的实现原理：
ArrayList的内部实现是基于数组的，它使用一个Object类型的数组来存储元素。当创建一个ArrayList实例时，会初始化一个默认大小的数组，当数组容量不足以存储新的元素时，ArrayList会自动扩展数组的大小，通常会将当前数组的容量增加一倍，并将原来的元素复制到新数组中，当然其他的操作也是类似。
通过上面的描述，我们就大致的了解了Java中ArrayList（顺序表）了。
2.ArrayList的创建
了解完了Java中ArrayList（顺序表），那么我们如何去创建并使用它呢？在Java中给我们提供了三种创建ArrayList（顺序表）的方式。
| 创建方式 | 解释 |
|---|---|
| ArrayList() | 无参构造 |
| ArrayList(int initialCapacity) | 指定顺序表初始容量 |
| ArrayList(Collection<? extends E> c) | 利用其他 Collection 构建 ArrayList |
现在让我们使用三种不同的方式来创建一下ArrayList（顺序表）：
（1）使用默认构造函数创建一个空的 ArrayList：
import java.util.ArrayList;public class Main {public static void main(String[] args) {// 创建一个空的 ArrayListArrayList<String> list1 = new ArrayList<>();// 添加元素到 ArrayList（这里可以先看一下就可以）list1.add("Apple");list1.add("Banana");list1.add("Orange");// 打印 ArrayListSystem.out.println("ArrayList 1: " + list1);}
}
（2）使用带有初始容量的构造函数创建 ArrayList：
import java.util.ArrayList;public class Main {public static void main(String[] args) {// 创建一个具有初始容量的 ArrayListArrayList<Integer> list2 = new ArrayList<>(5);// 添加元素到 ArrayList（这里先看一下就可以）list2.add(10);list2.add(20);list2.add(30);// 打印 ArrayListSystem.out.println("ArrayList 2: " + list2);}
}
（3）使用 ArrayList(Collection<? extends E> c) 构造函数创建 ArrayList 的简单示例：
import java.util.ArrayList;
import java.util.List;public class Main {public static void main(String[] args) {// 创建一个包含初始元素的集合List<String> originalList = new ArrayList<>();originalList.add("Apple");originalList.add("Banana");originalList.add("Orange");// 使用原始集合创建一个新的 ArrayListArrayList<String> newList = new ArrayList<>(originalList);// 打印新的 ArrayListSystem.out.println("New ArrayList: " + newList);}
}
这样我们就了解了如何在Java中创建ArrayList（顺序表）了。
3.ArrayList的遍历
在认识ArrayList的段落中，我们知道了ArrayList的底层是一个动态数组，既然是数组的话，我们是不是可以像遍历数组一样遍历ArrayList呢？答案是——是的，但是在此之上我们还可以使用迭代器对其进行遍历。
遍历ArrayList的方式：
（1）使用for循环
for (int i = 0; i < list.size(); i++) {int element = list.get(i);System.out.println(element);
}
（2）使用增强型for循环：
for (int element : list) {System.out.println(element);
}
（3）使用迭代器
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {int element = iterator.next();System.out.println(element);
}
以上就是三种遍历Java中ArrayList的方式，每种方式都有其适用的场景，我们需要根据实际需求选择最合适的方式来遍历ArrayList对象。
4.ArrayList常用API
在上文中，我们大致的了解了什么是Java中的ArrayList，以及学会了创建和遍历Java中的ArrayList，现在让我们学习一下Java中提供给我们的ArrayList中的常用API。
先让我们看一下有哪些常用的ArrayList中的API：
| 常用方法 | 解释 |
|---|---|
| boolean add(E e) | 尾插 e |
| void add(int index, E element) | 将 e 插入到 index 位置 |
| boolean addAll(Collection<? extends E> c) | 尾插 c 中的元素 |
| E remove(int index) | 删除 index 位置元素 |
| boolean remove(Object o) | 删除遇到的第一个 o |
| E get(int index) | 获取下标 index 位置元素 |
| E set(int index, E element) | 将下标 index 位置元素设置为 element |
| void clear() | 清空 |
| boolean contains(Object o) | 判断 o 是否在线性表中 |
| int indexOf(Object o) | 返回第一个 o 所在下标 |
| int lastIndexOf(Object o) | 返回最后一个 o 的下标 |
| List<E> subList(int fromIndex, int toIndex) | 截取部分 list |
这里我们一个一个的进行实例演示：
（1）boolean add(E e)——尾插 e
import java.util.ArrayList;public class Main {public static void main(String[] args) {// 创建一个空的 ArrayListArrayList<String> list = new ArrayList<>();// 向 ArrayList 中添加元素list.add("Apple");// 打印添加操作的结果System.out.println(list); // 输出：Apple}
}
在这个示例中，我们创建了一个空的 ArrayList，然后使用 add() 方法向其中添加了一个元素 "Apple"，最后打印了list。
（2）void add(int index, E element)——将 e 插入到 index 位置
import java.util.ArrayList;public class Main {public static void main(String[] args) {// 创建一个空的 ArrayListArrayList<String> list = new ArrayList<>();// 向 ArrayList 中指定位置添加元素list.add("Apple");list.add("Banana");list.add("Orange");System.out.println(list); // 输出：[Apple, Banana, Orange]list.add(1, "Grapes"); // 在索引 1 处添加元素 "Grapes"// 打印添加后的 ArrayListSystem.out.println(list); // 输出：[Apple, Grapes, Banana, Orange]}
}
在这个示例中，我们创建了一个空的 ArrayList，然后使用 add() 方法向其中添加了三个元素："Apple"、"Banana" 和 "Orange"。接着，我们使用 add(int index, E element) 方法在索引 1 处添加了元素 "Grapes"。最后，我们打印了添加后的 ArrayList，可以看到 "Grapes" 被成功添加到了索引 1 处。
（3）boolean addAll(Collection<? extends E> c)——尾插 c 中的元素
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class Main {public static void main(String[] args) {// 创建一个空的 ArrayListArrayList<String> list1 = new ArrayList<>();list1.add("Apple");list1.add("Banana");// 创建一个包含元素的集合List<String> elementsToAdd = Arrays.asList("Orange", "Grapes");// 使用 addAll() 方法将集合中的元素添加到 ArrayList 中list1.addAll(elementsToAdd); // 打印最终的 ArrayListSystem.out.println(list1); // 输出：[Apple, Banana, Orange, Grapes]}
}
在这个示例中，我们创建了一个空的 ArrayList，然后向其中添加了两个元素："Apple" 和 "Banana"。接着，我们创建了一个包含两个元素的集合 elementsToAdd。最后，我们使用 addAll() 方法将集合 elementsToAdd 中的元素添加到 ArrayList 中。
（4）E remove(int index)——删除 index 位置元素
import java.util.ArrayList;public class Main {public static void main(String[] args) {// 创建一个包含几个元素的 ArrayListArrayList<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Orange");// 打印原始的 ArrayListSystem.out.println("Original ArrayList: " + list); // 输出：[Apple, Banana, Orange]// 移除索引为 1 处的元素String removedElement = list.remove(1);// 打印被移除的元素和最终的 ArrayListSystem.out.println("Removed element: " + removedElement); // 输出：BananaSystem.out.println("Final ArrayList: " + list); // 输出：[Apple, Orange]}
}
在这个示例中，我们创建了一个包含三个元素的 ArrayList，然后使用 remove(int index) 方法移除了索引为 1 处的元素 "Banana"。最后，我们打印了被移除的元素和最终的 ArrayList，可以看到 "Banana" 被成功移除了。
（5）boolean remove(Object o)——删除遇到的第一个 o
import java.util.ArrayList;public class Main {public static void main(String[] args) {// 创建一个包含几个元素的 ArrayListArrayList<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Orange");// 打印原始的 ArrayListSystem.out.println("Original ArrayList: " + list); // 输出：[Apple, Banana, Orange]// 移除元素 "Banana"list.remove("Banana");// 打印最终的 ArrayListSystem.out.println(list); // 输出：[Apple, Orange]}
}
在这个示例中，我们创建了一个包含三个元素的 ArrayList，然后使用 remove(Object o) 方法移除了元素 "Banana"。最后，我们打印了最终的 ArrayList，可以看到 "Banana" 被成功移除了。
（6）E get(int index)——获取下标 index 位置元素
import java.util.ArrayList;public class Main {public static void main(String[] args) {// 创建一个包含几个元素的 ArrayListArrayList<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Orange");// 获取索引为 1 处的元素String element = list.get(1);// 打印获取到的元素System.out.println(element); // 输出：Banana}
}
在这个示例中，我们创建了一个包含三个元素的 ArrayList，然后使用 get(int index) 方法获取了索引为 1 处的元素。最后，我们打印了获取到的元素，可以看到获取操作成功返回了 "Banana" 这个元素。
（7）E set(int index, E element)——将下标 index 位置元素设置为 element
import java.util.ArrayList;public class Main {public static void main(String[] args) {// 创建一个包含几个元素的 ArrayListArrayList<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Orange");// 打印原始的 ArrayListSystem.out.println(list); // 输出：[Apple, Banana, Orange]// 将索引为 1 处的元素替换为 "Grapes"list.set(1, "Grapes");// 打印最终的 ArrayListSystem.out.println(list); // 输出：[Apple, Grapes, Orange]}
}
在这个示例中，我们创建了一个包含三个元素的 ArrayList，然后使用 set(int index, E element) 方法将索引为 1 处的元素 "Banana" 替换为 "Grapes"。最后，我们打印了最终的 ArrayList，可以看到替换操作成功地将 "Banana" 替换为了 "Grapes"。
（8）void clear()——清空
import java.util.ArrayList;public class Main {public static void main(String[] args) {// 创建一个包含几个元素的 ArrayListArrayList<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Orange");// 打印原始的 ArrayListSystem.out.println(list); // 输出：[Apple, Banana, Orange]// 使用 clear() 方法清空 ArrayListlist.clear();// 打印清空后的 ArrayListSystem.out.println(list); // 输出：[]}
}
在这个示例中，我们创建了一个包含三个元素的 ArrayList，然后使用 clear() 方法清空了该列表。最后，我们打印了清空后的 ArrayList，可以看到列表中不再包含任何元素。
（9）boolean contains(Object o)——判断 o 是否在线性表中
import java.util.ArrayList;public class Main {public static void main(String[] args) {// 创建一个包含几个元素的 ArrayListArrayList<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Orange");// 检查 ArrayList 是否包含元素 "Banana"boolean containsBanana = list.contains("Banana");// 打印检查结果System.out.println(containsBanana); // 输出：true}
}
在这个示例中，我们创建了一个包含三个元素的 ArrayList，然后使用 contains(Object o) 方法检查列表中是否包含元素 "Banana"。最后，我们打印了检查结果，可以看到列表中确实包含 "Banana" 元素。
（10）int indexOf(Object o)——返回第一个 o 所在下标
import java.util.ArrayList;public class Main {public static void main(String[] args) {// 创建一个包含几个元素的 ArrayListArrayList<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Orange");// 获取元素 "Banana" 在 ArrayList 中的索引int index = list.indexOf("Banana");// 打印索引值System.out.println(index); // 输出：1}
}
在这个示例中，我们创建了一个包含三个元素的 ArrayList，然后使用 indexOf(Object o) 方法获取了元素 "Banana" 在列表中的索引。最后，我们打印了索引值，可以看到 "Banana" 元素的索引是 1。
（11）int lastIndexOf(Object o)——返回最后一个 o 的下标
import java.util.ArrayList;public class Main {public static void main(String[] args) {// 创建一个包含几个元素的 ArrayListArrayList<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Orange");list.add("Banana");// 获取元素 "Banana" 在 ArrayList 中的最后一个索引int lastIndex = list.lastIndexOf("Banana");// 打印最后一个索引值System.out.println(lastIndex); // 输出：3}
}
在这个示例中，我们创建了一个包含四个元素的 ArrayList，其中包含两个 "Banana" 元素。然后使用 lastIndexOf(Object o) 方法获取了元素 "Banana" 在列表中的最后一个索引。最后，我们打印了最后一个索引值，可以看到最后一个 "Banana" 元素的索引是 3。
（12）List<E> subList(int fromIndex, int toIndex)——截取部分 list
import java.util.ArrayList;
import java.util.List;public class Main {public static void main(String[] args) {// 创建一个包含几个元素的 ArrayListArrayList<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Orange");list.add("Grapes");list.add("Kiwi");// 获取子列表，包括索引 1 到 3 的元素，但不包括索引 3List<String> subList = list.subList(1, 3);// 打印子列表System.out.println(subList); // 输出：[Banana, Orange]}
}
在这个示例中，我们创建了一个包含五个元素的 ArrayList，然后使用 subList(int fromIndex, int toIndex) 方法获取了子列表，包括索引 1 到 3 的元素，但不包括索引 3。最后，我们打印了子列表，可以看到子列表包含了 "Banana" 和 "Orange" 元素。
注意：
在使用List<E> subList(int fromIndex, int toIndex)方法的时候，我们对获取的子列表进行修改的时候，原来的列表也会被修改。
这样我们就大致的了解了Java中ArrayList的常用API了。
以上就是本篇文章的全部内容了~~~
