Java 集合基础超详细整理，从入门到精通

集合是 Java 中用于存储多个数据的容器，和数组功能相近，但具备长度动态可变的核心优势，也是项目开发中使用最频繁的容器技术。讲解集合概念、数组与集合区别、ArrayList创建与泛型、底层扩容原理、常用 API、内存运行机制以及多个实战案例，语法 + 代码 + 场景全覆盖，适合零基础学习、课后复习和面试备考。

一、集合介绍

1.1 什么是集合

集合是 Java 提供的数据容器，作用和数组一致，都可以用来批量存储多个数据。

1.2 集合与数组核心区别

1. 数组：一旦初始化完成，长度固定无法修改，适合数据数量固定的场景；
2. 集合：长度可动态变化，支持随时添加、删除元素，适配数据数量频繁变动的业务场景（如购物车、列表数据）。

1.3 Java 集合整体架构

Java 集合主要分为两大分支：Collection单列集合、Map双列集合。

• Collection常用实现类：ArrayList、LinkedList、HashSet、TreeSet、LinkedHashSet
• Map常用实现类：HashMap、TreeMap、LinkedHashMap

本章重点学习ArrayList，它是单列集合中最常用的实现类。

小结

数据个数固定优先使用数组；数据个数不确定、需要动态增删元素，优先选择集合。

二、ArrayList 底层变长原理

ArrayList底层依托数组实现，对外表现为长度可变，核心依靠自动扩容机制：

1. 空参创建ArrayList时，底层默认初始化一个长度为 10的空数组；
2. 当数组元素存满后，继续添加元素，会自动生成一个原长度 1.5 倍的新数组；
3. 将原数组中所有元素拷贝到新数组；
4. 最后把新元素存入新数组，完成自动扩容。

小结

ArrayList 本质是动态扩容的数组，使用者无需手动处理扩容，底层逻辑由 JDK 自动完成。

三、ArrayList 创建方式与泛型

3.1 两种创建写法

写法一：不指定泛型（不推荐）

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        // 可以存放任意数据类型
        list.add(1);
        list.add(12.3);
        list.add('a');
        list.add("abc");
        list.add(false);
    }
}

特点：无类型约束，能存储任意类型数据，容易引发类型转换异常，代码安全性差。

写法二：指定泛型（开发标准写法）

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        // JDK7及以上，右侧尖括号可省略类型
        ArrayList<String> list = new ArrayList<>();
        // 仅允许添加字符串类型
        list.add("abc");
        // list.add(100);  // 编译报错，类型不匹配
    }
}

3.2 泛型作用

<>为泛型标识，作用是约束集合中元素的数据类型，让代码更严谨、规范，避免类型混乱。补充规则：JDK 7 版本开始，构造方法右侧的泛型可以省略，编译器自动推断类型。

小结

实际开发中必须使用泛型约束元素类型，提升代码健壮性。

四、ArrayList 常用成员方法

下面是开发高频使用的方法，包含方法签名、功能说明与基础演示。

4.1 基础方法演示

import java.util.ArrayList;

public class ArrayListMethodDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        // 末尾添加元素
        list.add("张三");
        list.add("李四");
        list.add("王五");

        // 指定位置插入元素
        list.add(1, "赵六");

        // 获取元素、获取集合长度
        System.out.println("索引0元素：" + list.get(0));
        System.out.println("集合长度：" + list.size());

        // 根据索引删除
        list.remove(2);

        // 根据元素内容删除
        list.remove("王五");

        // 修改指定索引元素
        list.set(0, "小张");
    }
}

小结

增、删、改、查、获取长度是 ArrayList 五大核心操作，务必熟练掌握。

五、综合实战练习

练习一：集合存储字符串并遍历

需求：创建字符串集合，存入 3 个字符串元素，遍历输出所有内容。

import java.util.ArrayList;

public class StringArrayList {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        // 添加元素
        list.add("Java");
        list.add("MySQL");
        list.add("前端");

        // 普通for循环遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

练习二：集合存储学生对象并遍历（基础版）

需求：定义学生实体类，创建集合存储 3 个学生对象，遍历打印学生信息。

第一步：编写学生实体类

public class Student {
    // 成员变量
    private String name;
    private int age;

    // 无参、有参构造方法
    public Student(){}
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // get/set方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

第二步：测试遍历代码

import java.util.ArrayList;

public class StudentArrayList {
    public static void main(String[] args) {
        ArrayList<Student> stuList = new ArrayList<>();
        // 存入学生对象
        stuList.add(new Student("张三", 22));
        stuList.add(new Student("李四", 23));
        stuList.add(new Student("王五", 21));

        // 遍历集合
        for (int i = 0; i < stuList.size(); i++) {
            Student stu = stuList.get(i);
            System.out.println("姓名：" + stu.getName() + "，年龄：" + stu.getAge());
        }
    }
}

练习三：键盘录入学生信息存入集合

需求：循环录入 3 名学生的姓名、年龄，存入集合并遍历输出。

import java.util.ArrayList;
import java.util.Scanner;

public class InputStudentList {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        Scanner sc = new Scanner(System.in);

        // 循环录入3个学生信息
        for (int i = 1; i <= 3; i++) {
            System.out.print("请输入第" + i + "位学生姓名：");
            String name = sc.next();
            System.out.print("请输入第" + i + "位学生年龄：");
            int age = sc.nextInt();
            // 创建对象并加入集合
            list.add(new Student(name, age));
        }

        // 遍历输出
        for (int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName() + " | " + s.getAge());
        }
        sc.close();
    }

    /**
     * 封装添加学生的方法（对应PPT内存案例）
     */
    private static void addStudent(ArrayList<Student> list) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入姓名：");
        String name = scanner.next();
        System.out.println("请输入年龄：");
        int age = scanner.nextInt();
        Student stu = new Student(name, age);
        list.add(stu);
    }
}

5.1 集合存储对象内存说明

结合上方代码梳理内存运行逻辑：

1. main方法、自定义addStudent方法依次进入栈内存执行；
2. new ArrayList<>()、new Student() 都会在堆内存创建实体；
3. 栈中集合 / 对象变量仅保存堆内存地址，多个方法操作同一个集合时，本质操作堆中同一个实体；
4. 方法执行完毕，局部变量出栈释放，堆对象等待垃圾回收。

练习四：删除集合指定元素

需求：集合初始元素为 test、张三、李四、test、test，删除所有test元素，遍历剩余内容。

import java.util.ArrayList;

public class RemoveElementDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("test");
        list.add("张三");
        list.add("李四");
        list.add("test");
        list.add("test");

        // 正向遍历删除，删除后索引前移，需要i--防止漏删
        for (int i = 0; i < list.size(); i++) {
            if ("test".equals(list.get(i))) {
                list.remove(i);
                i--;
            }
        }

        // 遍历结果
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

练习五：集合元素筛选

需求：定义方法，接收学生集合，筛选出年龄小于 18的学生，存入新集合并返回。

import java.util.ArrayList;

public class FilterStudentDemo {
    public static void main(String[] args) {
        ArrayList<Student> oldList = new ArrayList<>();
        oldList.add(new Student("小明", 17));
        oldList.add(new Student("小红", 19));
        oldList.add(new Student("小刚", 16));

        // 调用筛选方法
        ArrayList<Student> newList = filterStudent(oldList);

        // 遍历筛选结果
        for (int i = 0; i < newList.size(); i++) {
            Student s = newList.get(i);
            System.out.println("未成年学生：" + s.getName());
        }
    }

    /**
     * 筛选年龄小于18的学生
     * @param srcList 原集合
     * @return 存放未成年学生的新集合
     */
    public static ArrayList<Student> filterStudent(ArrayList<Student> srcList) {
        ArrayList<Student> destList = new ArrayList<>();
        for (int i = 0; i < srcList.size(); i++) {
            Student stu = srcList.get(i);
            if (stu.getAge() < 18) {
                destList.add(stu);
            }
        }
        return destList;
    }
}

六、全文总结

1. 容器区分：数组长度固定，ArrayList 基于数组实现、支持动态扩容，数据可变场景优先使用集合；
2. 泛型使用：创建 ArrayList 建议指定泛型，约束元素类型，保证代码规范与安全；
3. 底层原理：默认底层数组长度为 10，存满后自动扩容为原长度 1.5 倍；
4. 核心 API：牢记add增、remove删、set改、get查、size获取长度五大方法；
5. 内存规则：集合、对象引用存于栈，真实实体存于堆，多方法操作同一集合会共享数据；
6. 实战要点：遍历优先使用普通 for 循环；删除重复元素需处理索引偏移；对象存储必须配合实体类使用。

ArrayList 是 Java 集合体系的入门核心，也是后续学习其他集合、框架代码的基础，建议多加练习增删改查、对象存储、元素筛选等案例，夯实基础。