ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，可以添加或删除元素。
ArrayList 继承了 AbstractList ，并实现了 List 接口。
import java.util.ArrayList; // 引入 ArrayList 类
ArrayList objectName =new ArrayList<>(); // 初始化
E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。
objectName: 对象名。
ArrayList 是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
除了使用 ArrayList 和 linkedList，还可以通过 List 接口提供的 of()方法，根据给定元素快速创建 List：
Listlist = List.of(1, 2, 5);
但是 List.of() 方法不接受 null 值，如果传入 null，会抛出NullPointerException异常。
添加元素ArrayList 类提供了很多有用的方法，添加元素到 ArrayList 可以使用 add() 方法:
import java.util.ArrayList;
public class RunoobTest {
public static void main(String[] args) {
ArrayList sites = new ArrayList();
sites.add("Google");
sites.add("Taobao");
sites.add(null); // List 还允许添加 null
sites.add("Weibo");
System.out.println(sites);
}
}
访问元素
访问 ArrayList 中的元素可以使用 get() 方法：
import java.util.ArrayList;
public class RunoobTest {
public static void main(String[] args) {
ArrayList sites = new ArrayList();
sites.add("Google");
sites.add("Taobao");
sites.add("Weibo");
System.out.println(sites.get(1)); // 访问第二个元素
}
}
注意：数组的索引值从 0 开始。
修改元素如果要修改 ArrayList 中的元素可以使用 set() 方法：
import java.util.ArrayList;
public class RunoobTest {
public static void main(String[] args) {
ArrayList sites = new ArrayList();
sites.add("Google");
sites.add("Taobao");
sites.add("Weibo");
sites.set(2, "Wiki"); // 第一个参数为索引位置，第二个为要修改的值
System.out.println(sites);
}
}
删除元素
如果要删除 ArrayList 中的元素可以使用 remove() 方法：
import java.util.ArrayList;
public class RunoobTest {
public static void main(String[] args) {
ArrayList sites = new ArrayList();
sites.add("Google");
sites.add("Taobao");
sites.add("Weibo");
sites.remove(2); // 删除第三个元素
System.out.println(sites);
}
}
计算大小
如果要计算 ArrayList 中的元素数量可以使用 size() 方法：
import java.util.ArrayList;
public class RunoobTest {
public static void main(String[] args) {
ArrayList sites = new ArrayList();
sites.add("Google");
sites.add("Taobao");
sites.add("Weibo");
System.out.println(sites.size());
}
}
迭代数组列表
我们可以使用 for 来迭代数组列表中的元素：
import java.util.ArrayList;
public class RunoobTest {
public static void main(String[] args) {
ArrayList sites = new ArrayList();
sites.add("Google");
sites.add("Taobao");
sites.add("Weibo");
for (int i = 0; i < sites.size(); i++) {
System.out.println(sites.get(i));
}
}
}
也可以使用 for-each 来迭代元素：
import java.util.ArrayList;
public class RunoobTest {
public static void main(String[] args) {
ArrayList sites = new ArrayList();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
for (String i : sites) {
System.out.println(i);
}
}
}
所以要始终坚持使用迭代器 Iterator 来访问 List。Iterator 本身也是一个对象，但它是由 List 的实例调用 iterator() 方法的时候创建的。Iterator 对象知道如何遍历一个 List，并且不同的 List 类型，返回的 Iterator 对象实现也是不同的，但总是具有最高的访问效率。
Iterator 对象有两个方法：boolean hasNext() 判断是否有下一个元素，E next() 返回下一个元素。因此，使用 Iterator 遍历 List 代码如下：
import java.util.Iterator;
import java.util.List;
public class Main {
public static void main(String[] args) {
List list = List.of("apple", "pear", "banana");
for (Iterator it = list.iterator(); it.hasNext(); ) {
String s = it.next();
System.out.println(s);
}
}
}
通过 Iterator 遍历 List 永远是最高效的方式。并且，由于 Iterator 遍历是如此常用，所以，Java 的 for each 循环本身就可以使用 Iterator 遍历。
import java.util.List;
public class Main {
public static void main(String[] args) {
List list = List.of("apple", "pear", "banana");
for (String s : list) {
System.out.println(s);
}
}
}
实际上，只要实现了 Iterable 接口的集合类都可以直接用 for each 循环来遍历，Java 编译器本身并不知道如何遍历集合对象，但它会自动把 for each 循环变成 Iterator 的调用，原因就在于 Iterable 接口定义了一个Iterator iterator() 方法，强迫集合类必须返回一个 Iterator 实例。
其他的引用类型ArrayList 中的元素实际上是对象，在以上实例中，数组列表元素都是字符串 String 类型。
如果我们要存储其他类型，而 只能为引用数据类型，这时就需要使用到基本类型的包装类。
基本类型对应的包装类表如下：
基本类型 引用类型
boolean Boolean
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
此外，BigInteger、BigDecimal 用于高精度的运算，BigInteger 支持任意精度的整数，也是引用类型，但它们没有相对应的基本类型。
ArrayList li=new Arraylist<>(); // 存放整数元素
ArrayList li=new Arraylist<>(); // 存放字符元素
以下实例使用 ArrayList 存储数字(使用 Integer 类型):
import java.util.ArrayList;
public class RunoobTest {
public static void main(String[] args) {
ArrayList myNumbers = new ArrayList();
myNumbers.add(10);
myNumbers.add(15);
myNumbers.add(20);
myNumbers.add(25);
for (int i : myNumbers) {
System.out.println(i);
}
}
}
ArrayList 排序
Collections 类也是一个非常有用的类，位于 java.util 包中，提供的 sort() 方法可以对字符或数字列表进行排序。
以下实例对字母进行排序：
import java.util.ArrayList;
import java.util.Collections; // 引入 Collections 类
public class RunoobTest {
public static void main(String[] args) {
ArrayList sites = new ArrayList();
sites.add("Taobao");
sites.add("Wiki");
sites.add("Weibo");
sites.add("Google");
Collections.sort(sites); // 字母排序
for (String i : sites) {
System.out.println(i);
}
}
}
以下实例对数字进行排序：
import java.util.ArrayList;
import java.util.Collections; // 引入 Collections 类
public class RunoobTest {
public static void main(String[] args) {
ArrayList myNumbers = new ArrayList();
myNumbers.add(33);
myNumbers.add(15);
myNumbers.add(20);
myNumbers.add(34);
myNumbers.add(8);
myNumbers.add(12);
Collections.sort(myNumbers); // 数字排序
for (int i : myNumbers) {
System.out.println(i);
}
}
}
Java ArrayList 方法
Java ArrayList 常用方法列表如下：
方法 描述
add() 将元素插入到指定位置的 arraylist 中
addAll() 添加集合中的所有元素到 arraylist 中
clear() 删除 arraylist 中的所有元素
clone() 复制一份 arraylist
contains() 判断元素是否在 arraylist
get() 通过索引值获取 arraylist 中的元素
indexOf() 返回 arraylist 中元素的索引值
removeAll() 删除存在于指定集合中的 arraylist 里的所有元素
remove() 删除 arraylist 里的单个元素
size() 返回 arraylist 里元素数量
isEmpty() 判断 arraylist 是否为空
subList() 截取部分 arraylist 的元素
set() 替换 arraylist 中指定索引的元素
sort() 对 arraylist 元素进行排序
toArray() 将 arraylist 转换为数组
toString() 将 arraylist 转换为字符串
ensureCapacity() 设置指定容量大小的 arraylist
lastIndexOf() 返回指定元素在 arraylist 中最后一次出现的位置
retainAll() 保留 arraylist 中在指定集合中也存在的那些元素
containsAll() 查看 arraylist 是否包含指定集合中的所有元素
trimToSize() 将 arraylist 中的容量调整为数组中的元素个数
removeRange() 删除 arraylist 中指定索引之间存在的元素
replaceAll() 将给定的操作内容替换掉数组中每一个元素
removeIf() 删除所有满足特定条件的 arraylist 元素
forEach() 遍历 arraylist 中每一个元素并执行特定操作
更多 API 方法可以查看：https://www.runoob.com/manual/jdk11api/java.base/java/util/ArrayList.html
把 List 变为 Array 有三种方法，第一种是调用 toArray() 方法直接返回一个 Object[] 数组：
import java.util.List;
public class Main {
public static void main(String[] args) {
List list = List.of("apple", "pear", "banana");
Object[] array = list.toArray();
for (Object s : array) {
System.out.println(s);
}
}
}
这种方法会丢失类型信息，所以实际应用很少。
第二种方式是给 toArray(T[]) 传入一个类型相同的 Array，List 内部自动把元素复制到传入的 Array 中：
import java.util.List;
public class Main {
public static void main(String[] args) {
List list = List.of(12, 34, 56);
Integer[] array = list.toArray(new Integer[3]);
for (Integer n : array) {
System.out.println(n);
}
}
}
注意到这个 toArray(T[]) 方法的泛型参数 并不是 List 接口定义的泛型参数 ，所以，我们实际上可以传入其他类型的数组，例如传入 Number 类型的数组，返回的仍然是 Number 类型：
import java.util.List;
public class Main {
public static void main(String[] args) {
List list = List.of(12, 34, 56);
Number[] array = list.toArray(new Number[3]);
for (Number n : array) {
System.out.println(n);
}
}
}
但是，如果传入类型不匹配的数组，例如，String[] 类型的数组，由于 List 的元素是 Integer，所以无法放入 String 数组，这个方法会抛出 ArrayStoreException。
如果传入的数组大小和 List 实际的元素个数不一致怎么办？根据 List 接口的文档，可以知道：
如果传入的数组不够大，那么 List 内部会创建一个新的刚好够大的数组，填充后返回；如果传入的数组比 List 元素还要多，那么填充完元素后，剩下的数组元素一律填充 null。
实际上，最常用的是传入一个“恰好”大小的数组：
Integer[] array = list.toArray(new Integer[list.size()]);
最后一种更简洁的写法是通过 List 接口定义的 T[] toArray(IntFunction
Integer[] array = list.toArray(Integer[]::new);
反过来，把 Array 变为 List 就简单多了，通过 List.of(T…) 方法最简单：
Integer[] array = { 1, 2, 3 };
List list = List.of(array);
对于JDK 11之前的版本，可以使用 Arrays.asList(T…) 方法把数组转换成List。
要注意的是，返回的 List 不一定就是 ArrayList 或者 linkedList，因为List 只是一个接口，如果我们调用 List.of()，它返回的是一个只读 List：
import java.util.List;
public class Main {
public static void main(String[] args) {
List list = List.of(12, 34, 56);
list.add(999); // UnsupportedOperationException
}
}
对只读 List 调用 add()、remove() 方法会抛出UnsupportedOperationException。
练习
给定一组连续的整数，例如：10，11，12，……，20，但其中缺失一个数字，试找出缺失的数字：
import java.util.*;
public class Main {
public static void main(String[] args) {
// 构造从start到end的序列：
final int start = 10;
final int end = 20;
List list = new ArrayList<>();
for (int i = start; i <= end; i++) {
list.add(i);
}
// 随机删除List中的一个元素:
int removed = list.remove((int) (Math.random() * list.size()));
int found = findMissingNumber(start, end, list);
System.out.println(list.toString());
System.out.println("missing number: " + found);
System.out.println(removed == found ? "测试成功" : "测试失败");
}
static int findMissingNumber(int start, int end, List list) {
return 0;
}
}
增强版：和上述题目一样，但整数不再有序，试找出缺失的数字：
import java.util.*;
public class Main {
public static void main(String[] args) {
// 构造从start到end的序列：
final int start = 10;
final int end = 20;
List list = new ArrayList<>();
for (int i = start; i <= end; i++) {
list.add(i);
}
// 洗牌算法shuffle可以随机交换List中的元素位置:
Collections.shuffle(list);
// 随机删除List中的一个元素:
int removed = list.remove((int) (Math.random() * list.size()));
int found = findMissingNumber(start, end, list);
System.out.println(list.toString());
System.out.println("missing number: " + found);
System.out.println(removed == found ? "测试成功" : "测试失败");
}
static int findMissingNumber(int start, int end, List list) {
return 0;
}
}
从下载练习：找出缺失的数字 （推荐使用IDE练习插件快速下载）
小结
List 是按索引顺序访问的长度可变的有序表，优先使用 ArrayList 而不是 linkedList；
可以直接使用 for each 遍历 List；
List 可以和 Array 相互转换。
