Java 中的 ArrayList 和 LinkedList

一、Java 中的列表

1.1 介绍

列表是一种数据结构，为了方便理解，我们可以认为它是动态的数组。众所周知，数组的大小在定义的时候就固定了，不可改变，那么它就无法存储超过它容量的数据，而列表的容量是无限大的，因为它可以随着其存储内容的大小进行动态的变化（包括容量扩增和缩小），这和 java.util.Vector 很像，但又不完全相同。

Java 中对列表的实现有两种，ArrayList 和 LinkedList。

1.2 继承结构

Java 的整个集合框架继承比较复杂，这里只画出和 ArrayList、LinkedList 相关的部分。

说明：灰色是接口（Interface），黄色是抽象类（AbstractClass），橙色是实现类（Class）；虚线是实现（inplements），实线是继承（extends）。

由上面可见，ArrayList 和 LinkedList 功能应该是类似的，只不过内部实现方式不同，各有优缺点，各有各的适用场景。它们都位于 java.util 中。

二、ArrayList

2.1 介绍

ArrayList 是 Java 中列表的一种实现，从类名中我们可以看出，它的底层是用数组实现的，因此 ArrayList 本质上就是一个数组队列，提供了添加、删除和修改等基本方法。

2.2 方法

下面给出类 ArrayList 的常用方法。

方法	描述
boolean add(E element)	将 element 添加到 ArrayList 的末尾，添加成功则返回 true
void add(int index, E element)	将 elemnet 插入到索引为 index 的位置
boolean addAll(Collection c)	将集合 c 中的所有元素添加到 ArrayList 的末尾，成功则返回 true
boolean addAll(int index, Collection c)	将集合 c 中的所有元素插入到索引为 index 的位置，成功则返回 true
void clear()	清除 ArrayList 的所有元素
Object clone()	返回 ArrayList 的浅拷贝
boolean contains(Object o)	判断 ArrayList 是否含有对象 o
boolean containsAll(Collection c)	判断 ArrayList 是否含有集合 c 中的全部对象 o
E get(int index)	返回索引值为 index 的元素
int indexOf(Object o)	返回对象 o 在 ArrayList 中最先出现的索引，不存在则返回 -1
int lastIndexOf(Object o)	返回对象 o 在 ArrayList 中最后出现的索引，不存在则返回 -1
boolean retainAll(Collection c)	保留 ArrayList 中与集合 c 的交叉元素，成功则返回 true
boolean removeAll(Collection c)	移除 ArrayList 中与集合 c 的交叉元素，成功则返回 true
boolean remove(Object o)	移除 ArrayList 中最先出现的一个对象 o
E remove(int index)	移除索引为 index 的元素并返回该元素
int size()	返回 ArrayList 的元素个数
boolean isEmpty()	判断 ArrayList 是否为空
List<E> subList(int fromIndex, int toIndex)	返回 ArrayList 索引从 fromIndex 开始，toIndex 结尾的部分，不包含索引为 toIndex 的元素
E set(int index, E element)	将 ArrayList 索引为 index 的元素替换为 element，并返回被替换的元素
void sort(Comparator c)	根据比较接口 c 来对 ArrayList 进行排序
Object[] toArray()	返回将 ArrayList 转换后的 Object 类型的数组，元素类型没有改变
T[] toArray(T[] a)	返回将 ArrayList 转换后的 T 类型数组
String toString()	将 ArrayList 转换成 String 类型
void ensureCapacity(int minCapacity)	将 ArrayList 的容量大小设置为 minCapacity
void trimToSize()	将 ArrayList 的容量大小设置为当前元素个数
void replaceAll(UnaryOperator<E> operator)	将 ArrayList 的每个元素都执行操作 operator，并替换将返回值替换原来的元素
boolean removeIf(Predicate<E> filter)	移除 ArrayList 中符合过滤器 filter 的元素，如果成功则返回 true
void forEach(Comsumer<E> action)	对 ArrayList 的每个元素都执行操作 action

代码示例：

import java.util.*;
class Test {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("ArrayList"); // 增加元素
        arrayList.add(0, "Java"); // 插入元素
        for (String s:arrayList) System.out.println(s); // 打印元素
        arrayList.replaceAll(String::toUpperCase); // 替换为大写
        arrayList.forEach(System.out::println); // 打印元素
        System.out.println(arrayList); // Output: [JAVA, ARRAYLIST]
    }
}

2.3 扩容机制

ArrayList 的底层实现是数组，但数组是定长，而 ArrayList 的动态大小的，因此 ArrayList 需要在容量不够的时候进行扩容。当容量不够的时候，ArrayList 会重新开一个原来 1.5 倍大小的新数组，并将原来的数据都搬到新的数组中去，以此来完成扩容的操作。

但这里有个问题，扩容之后，ArrayList 的数组会有很多空的部分，虽然只是 1.5 倍，看起来不是很多，但在原来的数组就特别大的情况下，这 1.5 倍就显得格外多了，太浪费了，而且可能导致机器内存不足。因此 ArrayList 就设计了一些方法来解决这个问题，比如方法 ensureCapacity，它可以一次性直接将容量设置到指定的大小，防止在某些情况自动扩容导致内存不足，而方法 trimToSize 可以将容量大小立即设置为当前元素的数量，这样数组中就不会有多余的部分了。

2.4 性能分析

因为 ArrayList 是用数组实现的，因此在遍历元素上非常有优势，但由于数组定长，扩容时需要新开辟内存空间，同时还要搬运原来的数据到新的数组中，效率较低，因此 ArrayList 在增减元素这方面就稍微慢了一点。

三、LinkedList

3.1 介绍

LinkedList 的底层是用链表实现的，链表是一种特殊的数据结构，主要分为单向链表和双向链表。除此之外，其余的都和 ArrayList 比较相像。

对于单向链表，每个节点都指向下一个节点的内存地址，而对于双向链表，每个节点都有两个分别指向前一个节点和后一个节点内存地址的值。LinkedList 的底层就是双向链表。

3.2 具体方法

下面具体描述 LinkedList 的常用方法。

方法	描述
boolean add(E e)	向 LinkedList 的末尾添加元素 e，成功则返回 true
void add(int index, E element)	向索引为 index 的位置添加元素 element
boolean addAll(Collection c)	将集合 c 中的全部元素添加到 LinkedList 的末尾，成功则返回 true
void addAll(int index, Collection c)	将集合 c 中的全部元素添加到 LinkedList 中索引为 index 的位置
void addFirst(E e)	将元素 e 添加到 LinkedList 的最前端
void addLast(E e)	将元素 e 添加到 LinkedList 的最后端
boolean offer(E e)	将元素 e 添加到 LinkedList 的末尾，成功则返回 true
boolean offerFirst(E e)	将元素 e 添加到 LinkedList 的最前端，成功则返回 true
boolean offerLast(E e)	将元素 e 添加到 LinkedList 的最后端，成功则返回 true
void clear()	清空 LinkedList 的全部元素
E removeFirst()	移除 LinkedList 中最前端的元素，并返回这个元素
E removeLast()	移除 LinkedList 中最后端的元素，并返回这个元素
boolean remove(Object o)	移除 LinkedList 中最先出现的对象 o，成功则返回 true
E remove(int index)	移除 LinkedList 中索引为 index 的元素
E poll()	移除 LinkedList 中最前端的元素，并返回这个元素
E remove()	移除 LinkedList 中最前端的元素，并返回这个元素
boolean contains(Object o)	判断 LinkedList 是否包含对象 o
E get(int index)	返回 LinkedList 中索引为 index 的元素
E getFirst()	返回 LinkedList 中最前端的元素
E getLast()	返回 LinkedList 中最后端的元素
int indexOf(Object o)	返回 LinkedList 中最先出现对象 o 的索引，若没有则返回 -1
int lastIndexOf(Object o)	返回 LinkedList 中最后出现对象 o 的索引，若没有则返回 -1
E element()	返回 LinkedList 的第一个元素
E peek()	返回 LinkedList 的第一个元素
E peekFirst()	返回 LinkedList 的头部元素
E peekLast()	返回 LinkedList 的尾部元素
E set(int index, E element)	将 LinkedList 中索引为 index 的元素替换为元素 element，并返回被替换的元素
Object clone()	返回 LinkedList 的浅拷贝
Iterator descendingIterator()	返回 LinkedList 的倒序迭代器
int size()	返回 LinkedList 的元素个数
ListIterator listIterator()	返回 LinkedList 的顺序迭代器
ListIterator listIterator(int index)	返回 LinkedList 从索引为 index 的位置开始的顺序迭代器
Object[] toArray()	返回将 LinkedList 转换后的 Object 类型的数组，元素类型没有改变
T[] toArray(T[] a)	返回将 LinkedList 转换后的 T 类型数组
String toString()	将 LinkedList 转换成 String 类型

代码示例：

import java.util.*;
class Test {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("LinkedList"); // 增加元素
        linkedList.add(0, "Java"); // 插入元素
        for (String s:linkedList) System.out.println(s); // 打印元素
        linkedList.replaceAll(String::toUpperCase); // 替换为大写
        linkedList.forEach(System.out::println); // 打印元素
        System.out.println(linkedList); // Output: [JAVA, LINKEDLIST]
    }
}

3.3 性能分析

LinkedList 的底层是用链表这种数据结构实现的，而链表每个节点之间是通过内存地址来联系的，因此它不能像数组那样直接访问到某一索引处的元素，只能从头开始遍历，直到找到该元素，所以 LinkedList 在遍历上性能偏低。但正因为它是由链表实现的，不需要像 ArrayList 那样对数组进行 1.5 倍大小的扩容，每次增加元素只需要扩增一个节点就行了，因此 LinkedList 在增减元素上性能较好。

四、二者的联系和区别

4.1 联系

ArrayList 和 LinkedList 都是用来存储数据的线性结构，都属于 Java 中的集合框架，都实现了 List 接口的功能。

4.2 区别

ArrayList 和 LinkedList 各有优缺点，适用场景不一样。

ArrayList 的底层数据结构是数组；LinkedList 的底层数据结构是链表；
ArrayList 在遍历元素上性能较优，而在增减元素上性能较差；LinkedList 在遍历元素上性能较差，而在增减元素上性能较优；
一般情况下，由于 ArrayList 的 1.5 倍扩容机制，因此 ArrayList 比 LinkedList 更占用内存空间；相同容量情况下，由于 LinkedList 每个节点需要记住前后节点的地址，因此 LinkedList 比 ArrayList 更加占用内存空间；

查找和修改需要较高的遍历性能，而增加和减少需要较高的增减性能。因此，若需要频繁地查找和修改元素，且一般只在末尾增减元素的情况下，应该采用 ArrayList；在需要频繁增减开头和中间部分元素的情况下，应该采用 LinkedList。