核心概念

ArrayList 是 Java 集合框架中一个最常用的类，它是一个动态数组，意味着它可以根据需要自动扩容，不像普通数组（如 int[]）在创建时就必须指定固定的大小。

ArrayList 位于 java.util 包中，所以使用前需要 import。

最基本的定义和初始化

这是最常见、最直接的方式,创建一个可以存储特定类型对象的空列表。

语法

import java.util.ArrayList;
// 创建一个指定元素类型的 ArrayList
ArrayList<元素类型> listName = new ArrayList<>();

• import java.util.ArrayList;：告诉编译器我们要使用 ArrayList 类。
• <元素类型>：这是泛型，你必须在尖括号 <> 中指定这个列表可以存放什么类型的对象。<String> 表示只能存放字符串，<Integer> 表示只能存放整数。
• listName：你为这个列表起的变量名。
• new ArrayList<>()：创建一个新的 ArrayList 对象，后面的 <> 可以省略（称为菱形语法）,因为编译器可以从变量的声明中推断出类型。

示例：创建一个存储字符串的列表

import java.util.ArrayList;
public class DefineArrayList {
    public static void main(String[] args) {
        // 1. 定义并初始化一个空的、可以存储 String 的 ArrayList
        ArrayList<String> names = new ArrayList<>();
        // 2. 向列表中添加元素
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        // 3. 打印列表内容
        System.out.println("列表内容: " + names); // 输出: 列表内容: [Alice, Bob, Charlie]
        System.out.println("列表大小: " + names.size()); // 输出: 列表大小: 3
    }
}

示例：创建一个存储整数的列表

import java.util.ArrayList;
public class DefineArrayListInt {
    public static void main(String[] args) {
        // 定义并初始化一个空的、可以存储 Integer 的 ArrayList
        // 注意：基本类型 int 必须使用其包装类 Integer
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        System.out.println("数字列表: " + numbers); // 输出: 数字列表: [10, 20, 30]
    }
}

带初始容量的定义

如果你预先知道这个列表大概会存放多少个元素，可以在创建时指定一个初始容量，这样做可以避免在后续添加元素时，因为数组空间不足而进行多次扩容操作,从而提高性能。

语法

ArrayList<元素类型> listName = new ArrayList<>(初始容量);

示例

import java.util.ArrayList;
public class DefineArrayListWithCapacity {
    public static void main(String[] args) {
        // 创建一个初始容量为 10 的 ArrayList
        // 如果预计会添加超过 10 个元素，列表会自动扩容
        ArrayList<String> students = new ArrayList<>(10);
        System.out.println("初始容量: " + students.size()); // 注意：size() 是元素个数，不是容量！
        // 输出: 初始容量: 0
        // 容量是底层数组的长度，size() 是当前存储的元素个数。
        students.add("张三");
        students.add("李四");
        System.out.println("当前元素个数: " + students.size()); // 输出: 当前元素个数: 2
    }
}

注意：capacity（容量）和 size（大小）是两个概念。

• 容量：ArrayList 底层数组的大小，当 size 超过 capacity 时，ArrayList 会创建一个更大的新数组,并将旧数组的内容复制过去。
• 大小：当前列表中实际存储的元素个数，通过 list.size() 获取。

使用另一个集合来初始化

你可以使用一个已经存在的集合（如另一个 ArrayList 或 LinkedList）来创建一个新的 ArrayList,新列表将包含原始集合中的所有元素。

语法

ArrayList<元素类型> newListName = new ArrayList<>(另一个集合对象);

示例

import java.util.ArrayList;
public class DefineArrayListFromCollection {
    public static void main(String[] args) {
        // 1. 创建一个原始列表
        ArrayList<String> originalList = new ArrayList<>();
        originalList.add("Apple");
        originalList.add("Banana");
        // 2. 使用 originalList 来初始化一个新列表
        ArrayList<String> copiedList = new ArrayList<>(originalList);
        System.out.println("原始列表: " + originalList); // 输出: 原始列表: [Apple, Banana]
        System.out.println("新列表: " + copiedList);      // 输出: 新列表: [Apple, Banana]
        // 修改新列表不会影响原始列表
        copiedList.add("Cherry");
        System.out.println("修改后的新列表: " + copiedList);      // 输出: [Apple, Banana, Cherry]
        System.out.println("原始列表保持不变: " + originalList); // 输出: [Apple, Banana]
    }
}

Java 8+ 的便捷初始化方式 (List.of)

从 Java 9 开始，List 接口提供了一个静态工厂方法 of()，可以非常方便地创建一个不可变的列表，虽然它返回的是 List 接口类型，但在很多情况下可以自动转换为 ArrayList。

重要提示： 使用 List.of() 创建的列表是不可变的，意味着你不能再向其中添加、删除或修改元素，如果尝试这样做，会抛出 UnsupportedOperationException 异常。

语法

import java.util.List;
import java.util.ArrayList;
// 创建一个不可变列表
List<元素类型> immutableList = List.of(元素1, 元素2, ...);
// 如果需要一个可变的 ArrayList，可以这样转换
ArrayList<元素类型> mutableList = new ArrayList<>(List.of(元素1, 元素2, ...));

示例

import java.util.List;
import java.util.ArrayList;
public class DefineArrayListWithListOf {
    public static void main(String[] args) {
        // 1. 创建一个不可变的 List
        List<String> colors = List.of("Red", "Green", "Blue");
        // 2. 为了得到一个可变的 ArrayList，用这个不可变 List 来初始化
        ArrayList<String> mutableColors = new ArrayList<>(colors);
        System.out.println("可变 ArrayList: " + mutableColors); // 输出: [Red, Green, Blue]
        // 现在可以安全地修改 mutableColors
        mutableColors.add("Yellow");
        System.out.println("添加后的 ArrayList: " + mutableColors); // 输出: [Red, Green, Blue, Yellow]
        // 尝试修改不可变列表会抛出异常
        // colors.add("Black"); // 这行代码会编译，但运行时会抛出 UnsupportedOperationException
    }
}

总结与最佳实践

最佳实践：

1. 始终使用泛型：永远不要使用 ArrayList list = new ArrayList(); 这种原始类型的方式，因为它会失去类型安全，可能导致运行时错误，始终指定 <String>, <Integer> 等。
2. 优先使用接口作为类型：在定义变量时，尽量使用接口 List 而不是具体实现类 ArrayList。

   // 更好的方式
   List<String> names = new ArrayList<>();
   // 如果未来需要换成 LinkedList，只需修改这一行
   // List<String> names = new LinkedList<>();

3. 选择合适的初始化方式：
   • 如果只是创建一个空列表，用 new ArrayList<>()。
   • 如果知道大概大小，用 new ArrayList<>(capacity)。
   • 如果想快速创建一个固定内容的列表，用 new ArrayList<>(List.of(...))。
   • 如果需要一个固定内容且不需要修改的列表，直接用 List.of(...)。