List集合

List是Java中最常用的集合类型之一，它是一个有序的集合，允许存储重复元素，并且可以通过索引访问元素。

作用

List集合在实际开发中具有以下重要价值：

有序性：维护元素的插入顺序，便于按序访问
索引访问：支持通过索引快速访问元素
动态扩容：自动管理容量，无需手动调整大小
重复元素：允许存储重复数据，适应更多场景
丰富API：提供大量便捷的操作方法

详细说明

ArrayList实现原理：
- 基于动态数组实现
- 初始容量为10
- 扩容时容量翻倍
- 适合随机访问，不适合频繁插入删除
LinkedList实现原理：
- 基于双向链表实现
- 每个节点包含前后引用
- 适合频繁插入删除
- 不适合随机访问

图表说明

内存结构

插入操作

删除操作

例子

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {
        // ArrayList示例
        List<String> arrayList = new ArrayList<>();
        arrayList.add("Java");
        arrayList.add("Python");
        arrayList.add("C++");

        System.out.println("ArrayList:");
        for(String lang : arrayList) {
            System.out.println(lang);
        }

        // LinkedList示例
        List<Integer> linkedList = new LinkedList<>();
        linkedList.add(10);
        linkedList.add(20);
        linkedList.add(1, 15); // 在索引1插入元素

        System.out.println("LinkedList:");
        for(int i = 0; i < linkedList.size(); i++) {
            System.out.println("索引" + i + ": " + linkedList.get(i));
        }

        // 常用方法
        System.out.println("包含Java吗? " + arrayList.contains("Java"));
        System.out.println("Python的索引: " + arrayList.indexOf("Python"));
        arrayList.remove("C++");
        System.out.println("删除后大小: " + arrayList.size());

        // 删除操作示例
        System.out.println("=== 删除操作示例 ===");

        // ArrayList删除操作
        List<String> arrayList2 = new ArrayList<>();
        arrayList2.add("Hello");
        arrayList2.add("张三");
        arrayList2.add("World");

        System.out.println("ArrayList删除前: " + arrayList2);
        arrayList2.remove(1); // 删除索引1的元素
        System.out.println("ArrayList删除后: " + arrayList2);

        // LinkedList删除操作
        List<String> linkedList2 = new LinkedList<>();
        linkedList2.add("Hello");
        linkedList2.add("张三");
        linkedList2.add("World");

        System.out.println("LinkedList删除前: " + linkedList2);
        linkedList2.remove(1); // 删除索引1的元素
        System.out.println("LinkedList删除后: " + linkedList2);

        // 删除操作的性能对比
        System.out.println("=== 删除操作性能对比 ===");
        List<Integer> arrayList3 = new ArrayList<>();
        List<Integer> linkedList3 = new LinkedList<>();

        // 初始化数据
        for(int i = 0; i < 100000; i++) {
            arrayList3.add(i);
            linkedList3.add(i);
        }

        // 测试ArrayList删除性能
        long startTime = System.nanoTime();
        arrayList3.remove(50000); // 删除中间元素
        long arrayListTime = System.nanoTime() - startTime;

        // 测试LinkedList删除性能
        startTime = System.nanoTime();
        linkedList3.remove(50000); // 删除中间元素
        long linkedListTime = System.nanoTime() - startTime;

        System.out.println("ArrayList删除耗时: " + arrayListTime/1000000.0 + "ms");
        System.out.println("LinkedList删除耗时: " + linkedListTime/1000000.0 + "ms");
    }
}

执行结果

ArrayList:
Java
Python
C++
LinkedList:
索引0: 10
索引1: 15
索引2: 20
包含Java吗? true
Python的索引: 1
删除后大小: 2
=== 删除操作示例 ===
ArrayList删除前: [Hello, 张三, World]
ArrayList删除后: [Hello, World]
LinkedList删除前: [Hello, 张三, World]
LinkedList删除后: [Hello, World]
=== 删除操作性能对比 ===
ArrayList删除耗时: 0.009166ms
LinkedList删除耗时: 1.473583ms

注意事项

ArrayList扩容会导致性能开销，初始化时可预估大小
LinkedList每个元素需要额外存储前后节点引用，内存占用更大
遍历ArrayList时，随机访问比迭代器更快
遍历LinkedList时，一定要使用迭代器，不要用get(index)
多线程环境下考虑使用Collections.synchronizedList或CopyOnWriteArrayList