Java List 集合详解：ArrayList、LinkedList、Vector 全解析

 一、java集合简介

1.集合简介

java集合可分为Set、List、Queue和Map四种体系。

Java集合就像一种容器，可以把多个对象（实际上是对象的引用，但习惯上都称对象）“丢进”该容器中。从Java 5 增加了泛型以后，Java集合可以记住容器中对象的数据类型，使得编码更加简洁、健壮。

2.集合和数组的区别

一、Java 集合简介

1. 集合简介

Java 集合是用于存储多个对象的容器（实际存储的是对象引用），从 Java 5 引入泛型后，集合可以明确存储元素的数据类型，让代码更简洁、健壮。Java 集合主要分为 Set、List、Queue 和 Map 四大体系，其中List 是有序、可重复的集合，也是日常开发中最常用的集合类型。

2. 集合和数组的区别

表格

特性 数组 集合
长度 固定长度，初始化后不可变 动态扩容，长度可自动调整
存储类型 可存储基本类型 / 引用类型 仅存储引用类型（对象）
功能 仅支持简单的增删查 提供丰富的操作方法（增删改查、遍历、排序等）
泛型支持 不支持 支持泛型，类型安全

二、ArrayList 集合

1. ArrayList 集合的特点

  • 底层基于动态数组实现，查询效率高（通过索引直接访问），增删效率低（需移动元素）；
  • 线程不安全，适合单线程环境；
  • 初始容量为 10，扩容时默认扩容为原容量的 1.5 倍；
  • 允许存储 null 值，元素有序且可重复。

2. ArrayList 集合的核心方法

（1）添加元素：add ()
import java.util.ArrayList;
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("青城"); // 向尾部添加元素
        list.add("博雅");
        list.add(1, "教育"); // 在指定索引位置插入元素
        System.out.println(list); // 输出：[青城, 教育, 博雅]
    }
}
（2）获取元素 / 长度：get ()、size ()
import java.util.ArrayList;
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("青城");
        list.add("博雅");
        System.out.println(list.size()); // 获取元素个数，输出：2
        System.out.println(list.get(1)); // 获取指定索引元素，输出：博雅
    }
}
（3）修改元素：set ()
import java.util.ArrayList;
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("qc");
        list.add("by");
        list.set(1, "wd"); // 替换指定索引元素
        System.out.println(list); // 输出：[qc, wd]
    }
}
（4）清空 / 判空：clear ()、isEmpty ()
import java.util.ArrayList;
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("qc");
        list.add("by");
        list.clear(); // 清空所有元素
        System.out.println(list.isEmpty()); // 判断是否为空，输出：true
    }
}
（5）判断元素存在：contains ()
import java.util.ArrayList;
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("qc");
        list.add("by");
        boolean flag = list.contains("gc"); // 判断是否包含指定元素
        System.out.println(flag); // 输出：false
    }
}
（6）删除元素：remove ()
import java.util.ArrayList;
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("青城");
        list.add("博雅");
        list.add("博雅");
        list.remove(1); // 按索引删除，返回被删元素
        list.remove("博雅"); // 按元素删除，返回是否删除成功
        System.out.println(list); // 输出：[青城]
    }
}
（7）遍历 ArrayList
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("青城");
        list.add("博雅");
        
        // 方式1：普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        
        // 方式2：增强for循环
        for (String name : list) {
            System.out.println(name);
        }
        
        // 方式3：迭代器
        Iterator<String> ite = list.iterator();
        while(ite.hasNext()) {
            System.out.println(ite.next());
        }
    }
}

三、LinkedList 集合

1. LinkedList 集合的特点

  • 底层基于双向链表实现，增删效率高（仅需修改节点引用），查询效率低（需遍历链表）；
  • 线程不安全，适合单线程环境；
  • 实现了 List 和 Deque 接口，可作为队列 / 栈使用；
  • 允许存储 null 值，元素有序且可重复。

2. LinkedList 集合的核心方法

import java.util.LinkedList;
public class LinkedListTest {
    public static void main(String[] args) {
        LinkedList<Integer> linkedList = new LinkedList<>();
        
        // 1. 添加元素
        linkedList.add(1); // 尾部添加
        linkedList.add(2);
        linkedList.addFirst(4); // 头部添加
        linkedList.addLast(6); // 尾部添加
        linkedList.add(2, 9); // 指定位置添加
        System.out.println("添加元素后：" + linkedList); // [5,4,9,1,2,3,6]
        
        // 2. 获取元素
        System.out.println("下标1的元素：" + linkedList.get(1)); // 4
        System.out.println("第一个元素：" + linkedList.getFirst()); // 5
        System.out.println("最后一个元素：" + linkedList.getLast()); // 6
        
        // 3. 查询元素
        System.out.println("是否包含1：" + linkedList.contains(1)); // true
        
        // 4. 修改元素
        linkedList.set(1, 9);
        System.out.println("修改后：" + linkedList); // [5,9,9,1,2,3,6]
        
        // 5. 删除元素
        linkedList.remove(); // 删除第一个元素
        linkedList.remove(2); // 删除指定位置元素
        linkedList.removeFirst(); // 删除头部元素
        linkedList.removeLast(); // 删除尾部元素
        System.out.println("删除后：" + linkedList);
        
        // 6. 清空/长度
        linkedList.clear(); // 清空所有元素
        System.out.println("清空后：" + linkedList); // []
        System.out.println("链表长度：" + linkedList.size()); // 0
    }
}

四、Vector 集合（不建议使用）

1. Vector 集合的特点

  • 底层基于动态数组实现，与 ArrayList 功能类似；
  • 所有方法均为同步方法（synchronized），线程安全，但效率低；
  • 初始容量为 10，扩容时默认扩容为原容量的 2 倍（可指定扩容增量）；
  • 属于 Java 早期集合类，性能较差，推荐使用CopyOnWriteArrayList替代。

2. Vector 集合完整示例

import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

public class VectorCompleteExample {
    public static void main(String[] args) {
        // 1. 创建Vector对象
        Vector<String> vector = new Vector<>(); // 空Vector（默认容量10）
        Vector<Integer> vectorWithCapacity = new Vector<>(10); // 指定初始容量
        Vector<Double> vectorWithIncrement = new Vector<>(10, 5); // 指定容量+扩容增量

        // 2. 添加元素
        vector.add("Apple"); // 通用添加方法
        vector.add("Banana");
        vector.addElement("Cherry"); // Vector特有方法
        System.out.println("添加元素后: " + vector); // [Apple, Banana, Cherry]

        // 3. 访问元素
        String fruit1 = vector.get(1); // 通用方法
        String fruit2 = vector.elementAt(2); // Vector特有方法
        System.out.println("索引1的元素: " + fruit1); // Banana
        System.out.println("索引2的元素: " + fruit2); // Cherry

        // 4. 修改元素
        vector.set(1, "Blueberry");
        System.out.println("修改后: " + vector); // [Apple, Blueberry, Cherry]

        // 5. 删除元素
        vector.remove(1); // 按索引删除
        vector.removeElement("Cherry"); // 按元素删除（特有）
        System.out.println("删除后: " + vector); // [Apple]

        // 6. 获取大小和容量
        vector.add("Banana");
        vector.add("Cherry");
        System.out.println("元素数量: " + vector.size()); // 3
        System.out.println("当前容量: " + vector.capacity()); // 10

        // 7. 遍历Vector
        System.out.println("\n=== 普通for循环 ===");
        for (int i = 0; i < vector.size(); i++) {
            System.out.println(vector.get(i));
        }

        System.out.println("\n=== Iterator遍历 ===");
        Iterator<String> iterator = vector.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        System.out.println("\n=== Enumeration遍历（特有） ===");
        Enumeration<String> enumeration = vector.elements();
        while (enumeration.hasMoreElements()) {
            System.out.println(enumeration.nextElement());
        }

        // 8. 检查元素存在
        System.out.println("\n是否包含Apple: " + vector.contains("Apple")); // true

        // 9. 转换为数组
        String[] fruitArray = vector.toArray(new String[0]);
        System.out.println("\n=== 数组遍历 ===");
        for (String fruit : fruitArray) {
            System.out.println(fruit);
        }

        // 10. 其他方法
        vector.trimToSize(); // 缩容至实际元素数量
        System.out.println("\n缩容后容量: " + vector.capacity()); // 3
    }
}

3. Vector 线程安全性演示

import java.util.Vector;

public class VectorThreadSafeExample {
    public static void main(String[] args) throws InterruptedException {
        Vector<Integer> sharedVector = new Vector<>();
        
        // 多线程添加元素
        Runnable addTask = () -> {
            for (int i = 0; i < 1000; i++) {
                sharedVector.add(i);
            }
        };
        
        Thread thread1 = new Thread(addTask);
        Thread thread2 = new Thread(addTask);
        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
        
        System.out.println("最终元素数量: " + sharedVector.size()); // 2000（线程安全）
    }
}

五、List 集合总结

表格

集合类型 底层实现 线程安全 查询效率 增删效率 扩容规则 适用场景
ArrayList 动态数组 不安全 高 低 默认 1.5 倍扩容 单线程、查询多、增删少的场景
LinkedList 双向链表 不安全 低 高 无需扩容（链表结构） 单线程、增删多、查询少的场景
Vector 动态数组 安全 高 低 默认 2 倍扩容（可指定增量） 多线程（不推荐，效率低）

核心选型建议

  1. 日常开发优先使用ArrayList（性能最优）；
  2. 频繁增删操作选LinkedList（如队列 / 栈场景）；
  3. 多线程环境需线程安全时，优先使用CopyOnWriteArrayList替代 Vector；
  4. 避免在循环中频繁调用 ArrayList 的 remove/add 方法（可先转为 LinkedList 操作）。

# java # 开发语言
Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

当 AI 修图师装上“万能插头“：MCP 如何改变修图工作流

avatar AI编程社区
cover

2026年8月开发者实战指南：ChatGPT Plus / Pro + Codex 如何协同完成需求分析、编码、测试、调试与代码审查

avatar AI编程社区
cover

投资一台B300，部署Claude Opus 5多久才能回本？

avatar AI编程社区