8
1
0

List 接口

2026-08-21
2026-08-21

1.List

1.1 什么是 List

　　 在集合框架中，List​是⼀个接⼝，继承⾃Collection。

　　 Collection 也是⼀个接⼝，该接⼝中规范了后序容器中常⽤的⼀些⽅法，具体如下所⽰：

　　 Iterable 也是⼀个接⼝，表⽰实现该接⼝的类是可以逐个元素进⾏遍历的，具体如下：

　　 站在数据结构的⻆度来看，List 就是⼀个线性表，即 n 个具有相同类型元素的有限序列，在该序列上可以执⾏增删改查以及变量等操作。

　　 由于 List 是一个接口，不可以被实例化，如果要使用，必须通过实例化 List 的实现类，在集合框架中，ArrayList 和 LinkedList 都实现了 List 接口。

1.2 List 接口的一些方法

　　‍

2.ArrayList 实现类

2.1 什么是 ArrayList

　　这个是 ArrayList 的框架图，下面有几点说明：

  1. ArrayList 是以泛型⽅式实现的，使⽤时必须要先实例化
  2. ArrayList​实现了 RandomAccess​接⼝，表明 ArrayList⽀持随机访问
  3. ArrayList​实现了 Cloneable​接⼝，表明 ArrayList​是可以 clone 的
  4. ArrayList 实现了 Serializable 接⼝，表明 ArrayList 是⽀持序列化的
  5. 和 Vector​不同，ArrayList​不是线程安全的，在单线程下可以使⽤，在多线程中可以选择 Vector​或者 CopyOnWriteArrayList
  6. ArrayList 底层是⼀段连续的空间，并且可以动态扩容，是⼀个动态类型的顺序表

2.2 ArrayList 使⽤

2.2.1 ArrayList 的构造

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

public class TestDemo {
    public static void main(String[] args) {
        // ArrayList创建，推荐写法
        // 构造一个空的列表
        List<Integer> list1 = new ArrayList<>();

        // 构造一个具有10个容量的列表
        List<Integer> list2 = new ArrayList<>(10);
        list2.add(1);
        list2.add(2);
        list2.add(3);
        // list2.add("hello"); 
        // 编译失败，List<Integer>已经限定了，list2中只能存储整形元素

        // list3构造好之后，与list2中的元素一致
        ArrayList<Integer> list3 = new ArrayList<>(list2);

        // 避免省略类型，否则：任意类型的元素都可以存放，使用时将是一场灾难
        List list4 = new ArrayList();
        list4.add("111");
        list4.add(100);
    }
}

2.2.2 ArrayList 的方法

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

public class ListDemo {
    public static void main(String[] args) {
        // 初始化集合并添加元素
        List<String> list = new ArrayList<>();
        list.add("JavaSE");
        list.add("JavaWeb");
        list.add("JavaEE");
        list.add("JVM");
        list.add("测试课程");
        System.out.println(list);

        // *获取有效元素个数
        System.out.println(list.size());

        // *获取、修改指定下标元素
        System.out.println(list.get(1));
        list.set(1, "JavaWEB");
        System.out.println(list.get(1));

        // *指定下标插入元素，后续元素后移
        list.add(1, "Java数据结构");
        System.out.println(list);

        // *按元素内容删除，后续元素前移
        list.remove("JVM");
        System.out.println(list);

        // *按下标删除最后一个元素
        list.remove(list.size() - 1);
        System.out.println(list);

        // *判断是否包含元素，包含则追加
        if (list.contains("测试课程")) {
            list.add("测试课程");
        }

        // *查找元素首次、末次出现下标
        list.add("JavaSE");
        System.out.println(list.indexOf("JavaSE"));
        System.out.println(list.lastIndexOf("JavaSE"));

        // *截取[0,4)范围子列表，子列表与原集合共享底层数组
        List<String> ret = list.subList(0, 4);
        System.out.println(ret);

        // *清空集合
        list.clear();
        System.out.println(list.size());
    }
}

2.2.3 ArrayList 的遍历

　　遍历共有三种方法：for+ 下标、增强 for 以及迭代器

　　迭代器（Iterator​）是一个接口，用来安全遍历 Collection​ 系列集合，遍历期间用迭代器自身方法增删元素不会触发修改异常，for/foreach​ 遍历直接增删元素会触发 ConcurrentModificationException 异常。

　　其获取迭代器对象的方法为：Iterator<E> iterator() = list.interator();，其中 E 可以填 List 的类型，也可以填类型占位符。

　　其有 2 个方法核心方法：

　　 1.boolean hasNext()​，判断集合是否还有下一个，有的话返回 true。

　　 2.E next()，先指正后移，再返回当前指向的元素

[!WARNING]
迭代器注意事项

  1. 调用顺序不能乱，应该是先 hasNext()​ 先判断，再 next()​ 取值；连续多次 next()​ 会出现 NoSuchElementException（没有可操作的元素异常）异常
  2. foreach 的本质就是迭代器
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListTraverseDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        // 使用for+下标遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();

        // 借助增强 for 遍历
        for (Integer integer : list) {
            System.out.print(integer + " ");
        }
        System.out.println();

        // 迭代器
        ListIterator<Integer> it = list.listIterator();
        while(it.hasNext()){
            System.out.print(it.next() + " ");
        }
        System.out.println();
    }
}

2.3 ArrayList 的扩容机制

  1. 无参构造时，ArrayList() 构造一个初始容量为 10 的空列表。另外不是一 new 底层就会创建一个长度为 10 的空数组,而是第一次 add 的时候底层才会创建一个长度为 10 的空数组。
  2. 如果超出了数组的容量,会自动扩容,每次扩容 1.5 倍

2.4 ArrayList 的缺陷

　　 ArrayList 底层使⽤数组来存储元素；由于其底层是⼀段连续空间，当在 ArrayList 任意位置插⼊或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为 O(n)，效率⽐较低，因此 ArrayList 不适合做任意位置插⼊和删除⽐较多的场景。因此：java 集合中⼜引⼊了 LinkedList，即链表结构。

3.LinkList 实现类

3.1 什么是 LinkedList

　　 LinkedList 的底层是双向链表结构(链表后⾯介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引⽤将节点连接起来了，因此在在任意位置插⼊或者删除元素时，不需要搬移元素，效率⽐较⾼。

　　‍

　　 在集合框架中，LinkedList 也实现了 List 接⼝，具体如下：

　　说明：

  1. LinkedList​实现了 List 接⼝
  2. LinkedList 的底层使⽤了双向链表
  3. LinkedList​没有实现 RandomAccess​接⼝，因此 LinkedList 不⽀持随机访问
  4. LinkedList​的任意位置插⼊和删除元素时效率⽐较⾼，时间复杂度为 O(1)
  5. LinkedList⽐较适合任意位置插⼊的场景

3.2 LinkedList 的使用

3.2.1 LinkedList 的构造

public static void main(String[] args) {
    // 构造一个空的LinkedList
    List<Integer> list1 = new LinkedList<>();
    
    // 等价于new ArrayList<>(); 构造一个空的 List 类型的ArrayList集合
    List<String> list2 = new java.util.ArrayList<>();
    list2.add("JavaSE");
    list2.add("JavaWeb");
    list2.add("JavaEE");
    // 使用ArrayList构造LinkedList
    List<String> list3 = new LinkedList<>(list2);
}

3.2.2 LinkedList 的方法

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

public class TestLinkedList {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1); // add(elem): 表示尾插
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        System.out.println(list.size());
        System.out.println(list);

        // 在起始位置插入0
        list.add(0, 0); // add(index, elem): 在index位置插入元素elem
        System.out.println(list);

        list.remove(); // remove(): 删除第一个元素，内部调用的是removeFirst()
        list.removeFirst(); // removeFirst(): 删除第一个元素
        list.removeLast(); // removeLast(): 删除最后元素
        list.remove(1); // remove(index): 删除index位置的元素
        System.out.println(list);

        // contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
        if(!list.contains(1)){
            list.add(0, 1);
        }
        list.add(1);
        System.out.println(list);
        System.out.println(list.indexOf(1)); // indexOf(elem): 从前往后找到第一个elem的位置
        System.out.println(list.lastIndexOf(1)); // lastIndexOf(elem): 从后往前找第一个1的位置
        int elem = list.get(0); // get(index): 获取指定位置元素
        list.set(0, 100); // set(index, elem): 将index位置的元素设置为elem
        System.out.println(list);

        // subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
        List<Integer> copy = list.subList(0, 3);
        System.out.println(list);
        System.out.println(copy);
        list.clear(); // 将list中元素清空
        System.out.println(list.size());
    }
}

3.2.3 LinkedList 的遍历

import java.util.LinkedList;
import java.util.ListIterator;

public class LinkedListTraverse {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);    // add(elem)：表示尾插
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);

        System.out.println(list.size());

        // foreach遍历
        for (int e:list) {
            System.out.print(e + " ");
        }
        System.out.println();

        // 使用迭代器遍历---正向遍历
        ListIterator<Integer> it = list.listIterator();
        while(it.hasNext()){
            System.out.print(it.next()+ " ");
        }
        System.out.println();

        // 使用反向迭代器---反向遍历
        ListIterator<Integer> rit = list.listIterator(list.size());
        while (rit.hasPrevious()){
            System.out.print(rit.previous() + " ");
        }
        System.out.println();
    }
}

4.ArrayList 与 LinkedList 的区别

　　

不同点 ArrayList LinkedList
存储空间上 物理上一定连续 逻辑上连续，但物理上不一定连续
随机访问 支持 O(1) 不支持：O(n)
头插 需要搬移元素，效率低 O(n) 只需修改引用的指向，时间复杂度为 O(1)
插入 空间不够时需要扩容 没有容量的概念
应用场景 元素高效存储 + 频繁访问 任意位置插入和删除频繁

　　‍

　　‍

支持与分享

如果这篇文章对你有帮助，欢迎分享给更多人或者给予支持！

List 接口
/archives/post-1787301685603
作者
Bam
发布于
2026-08-21
许可协议
CC BY-NC-SA 4.0

评论