ArrayList和LinkedList都继承了AbstractList抽象类,上层实现了List接口,又根据自我定位,实现不同的功能
二、ArrayList的实现
ArrayList是基于数组实现的,在底层维护了一个 Object 类的数组用来存放元素
2.1 ArrayList实现类
ArrayList的类定义:
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
- 实现 List 接口,继承了 AbstractList 抽象类,这个是很好理解的,ArrayList作为List集合类家族的一部分,可以更好的将公用方法抽象给上层
- 实现Cloneable和Serializable接口 ,可以进行克隆和序列化操作
- 实现RandomAccess接口,这个接口会相对陌生点,点进去官方给的解释是,RandomAccess是一个标记接口,是一个空接口,仅起到标记的作用(类似Serializable接口)
public interface RandomAccess { }
List实现这个接口表明这个类能实现 快速随机访问。该接口的主要目的是允许通用算法更改其行为,以便在应用于随机访问或顺序访问列表时提供良好的性能
而后文档里给了说明,如果实现了RandomAccess接口,对List做查询操作时使用for循环的方式,否则使用迭代器的方式。这样做的原因做了RandomAccess接口标记的LIst实现类底层数据结构使用for循环效率更高(比如ArrayList),没有RandomAccess接口标记的使用迭代器效率更高(比如LinkedList,下文可以看到LinkedList没有实现RandomAccess接口)
举个简单的小例子,比如Collections类里的二分查找方法,就是用是否标记了RandomAccess接口来区分用哪种方法实现的:
public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) {
if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
return Collections.indexedBinarySearch(list, key); // for循环方法
else
return Collections.iteratorBinarySearch(list, key); // Iterator循环方法
}
2.2 ArrayList构造函数
ArrayList实现了三种构造函数用于不同情形下的对象创建
- 无参构造函数
构造了一个空数组,在首次添加元素的时候才给数据设置大小public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
- 给定初始容量的构造函数
通过参数 initialCapacity 可设置List数组的初始大小,这样做的好处是当 ArrayList 新增元素时,如果所存储的元素已经超过其已有大小,它会计算元素大小后再进行动态扩容,数组的扩容会导致整个数组进行一次内存复制。因此,我们在初始化 ArrayList 时,可以通过第一个构造函数合理指定数组初始大小,这样有助于减少数组的扩容次数,从而提高系统性能public ArrayList(int initialCapacity) { if (initialCapacity > 0) { // initialCapacity大于0,数组的大小为initialCapacity值 this.elementData = new Object[initialCapacity]; } else if (initialCapacity == 0) { // initialCapacity等于0,生成默认空数组EMPTY_ELEMENTDATA this.elementData = EMPTY_ELEMENTDATA; } else { // 其他情况,报非法参数异常-》数组的大小必须大于等于0 throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); } }
- 传入Collection对象转化成ArrayList
public ArrayList(Collection<? extends E> c) { Object[] a = c.toArray(); if ((size = a.length) != 0) { if (c.getClass() == ArrayList.class) { elementData = a; } else { elementData = Arrays.copyOf(a, size, Object[].class); } } else { // replace with empty array. elementData = EMPTY_ELEMENTDATA; } }
将 Collection 转化为数组并赋值给 elementData,把 elementData 中元素的个数赋值给 size。 如果 size 不为零,则判断 elementData 的 class 类型是否为 Object[],不是的话则做一次转换。 如果 size 为零,则把 EMPTY_ELEMENTDATA 赋值给 elementData,相当于new ArrayList(0)
2.3 ArrayList属性
ArrayList主要包含了三个属性:
- elementData :底层数组,用来存储数据
- DEFAULT_CAPACITY :数组的默认初始化容量 10
- size :当前的数组大小,用来表示当前数组包含了多少个元素
transient Object[] elementData; // non-private to simplify nested class access private static final int DEFAULT_CAPACITY = 10; private int size;
2.4 ArrayList新增元素
ArrayList提供了两种添加元素的方法,第一种:直接将元素添加到数组尾部;第二种:将元素添加到指定位置
/**
* 直接将元素添加到数组尾部
*/
public boolean add(E e) {
// 1.判断当前数组容量是否够用,不够的话进行数组扩容操作
ensureCapacityInternal(size + 1); // Increments modCount!!
// 2.将元素添加到数组尾部,size加1
elementData[size++] = e;
return true;
}
/**
* 将元素添加到指定位置
*/
public void add(int index, E element) {
// 1.判断指定位置是否在数组包含范围内
rangeCheckForAdd(index);
// 2.判断当前数组容量是否够用,不够的话进行数组扩容操作
ensureCapacityInternal(size + 1); // Increments modCount!!
// 3.将指定位置开始的元素向后挪动一位
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
// 4.将元素添加到指定位置上
elementData[index] = element;
size++;
}
从代码里可以看出,两种添加方式都执行了 ensureCapacityInternal 方法,判断数组的容量情况,具体看下这个方法是如何实现的呢:
判断当前数组是否是空数组EMPTY_ELEMENTDATA,如果是的话,判断默认值(10)和传入的容量(size+1)谁大,就返回哪个,如果不是空数组的话,直接返回(size+1),这一步是对初始化为空数组的情况进行特殊处理
判断传入容量(size+1)是否大于当前的数组大小,如果是的话进行扩容操作(grow)
扩容操作是将容量扩充到原始容量的1.5倍大小(oldCapacity + (oldCapacity >> 1)),如果还是不够,就将容量给定为当前传入的容量(size+1)
这里需要判断下是否有内存溢出的问题,当容量达到允许的最大值(MAX_ARRAY_SIZE)的时候,将数组容量给定为int最大值
扩容后需要将原数组重新分配到新的内存地址中
/**
* 计算数组容量,从传入的容量和默认容量(10)里面去较大的
*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
/**
* 计算数组容量,从传入的容量和默认容量(10)里面去较大的
*/
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
/**
* 计算数组容量,如果传入容量比当前数组已有元素数量小,需要进行扩容操作
*/
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/**
* 数组扩容
*/
private void grow(int minCapacity) {
// 计算扩容后的数组容量
// overflow-conscious code
int oldCapacity = elementData.length;
// 扩容后新的容量是原容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 将原数组的元素复制到新数组上
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
/**
* 数据容量大小边界处理
*/
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
/**
* 数据允许的最大容量
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
从代码里可以看到,添加元素到任意位置,会导致在该位置后的所有元素都需要重新排列,而将元素添加到数组的末尾,在没有发生扩容的前提下,是不会有元素复制排序过程的。所以直接将元素添加的数组的末尾效率会更高。
2.5 ArrayList查找元素
ArrayList在数据查找上的效率很高,只需要O(1)的时间复杂度就能获取数据,传入需要元素的下标index,返回数据中的对应元素即可
public E get(int index) {
// 检查index是否越界,
rangeCheck(index);
// 返回数组对应下标元素值
return elementData(index);
}
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
2.6 ArrayList删除元素
ArrayList删除元素的代码逻辑和添加元素到任意位置的方法类似,在每一次有效的删除元素操作之后,都要进行数组的重组,并且删除的元素位置越靠前,数组重组的开销就越大
- 判断index是否合法(有没有下标越界)
- 获取要删除的元素
- 将要删除数据下标往后的元素向前移动一位
- 将最后一位置零
- 返回被删除的元素
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
三、LinkedList的实现
虽然LinkedList和ArrayList都同属于List集合下的,但在实现上却有很大的区别。LinkedList是基于双向链表实现的,LinkedList 定义了一个 Node 结构用来存储数据,Node里维护了三个属性:
- item:用来存储元素内容
- next:指向下一个节点地址
- prev:指向上一个节点地址
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
3.1 LinkedList实现类
- 实现了 List 接口,有了List类型的特点
- 实现了 Deque 接口,有了Queue类型的特点
- 实现了Cloneable 和 Serializable 接口,可以实现克隆和序列化
⚠️ 由于 LinkedList 存储数据的内存地址是不连续的,而是通过指针来定位不连续地址,因此,LinkedList 不支持随机快速访问,LinkedList 也就不能实现 RandomAccess 接口
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
3.2 LinkedList构造函数
由于LinkedList是双向链表,不像ArrayList那样可以提前设定容量大小,所以LinkedList只有两个构造函数,一个是空构造器,一个是将传入的Collection数据全部存入
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
3.3 LinkedList属性
LinkedList同样也包含了三个属性:
- size :记录前LinkedList存储的元素节点个数
- first :双向链表的头节点
- last :双向链表的尾节点
在JDK1.7以后使用了first/last节点来表示双向链表,而不是之前的使用head节点,这样的好处有:
- first/last 属性能更清晰地表达链表的链头和链尾概念
- first/last 方式可以在初始化 LinkedList 的时候节省 new 一个 Entry
- first/last 方式最重要的性能优化是链头和链尾的插入删除操作更加快捷了
除此之外可以看到这三个属性都被 transient 修饰了,原因很简单,我们在序列化的时候不会只对头尾进行序列化,所以 LinkedList 也是自行实现 readObject 和 writeObject 进行序列化与反序列化
transient int size = 0;
/**
* Pointer to first node.
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
transient Node<E> first;
/**
* Pointer to last node.
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
transient Node<E> last;
3.4 LinkedList新增元素
LinkedList提供了多种插入数据的方式:
默认的add(E element)是将数据添加到链表的尾部,首先创建一个新的节点对象,将之前的last指针指向对象的next节点指向新对象,将last指针指向新对象,完成尾插
public boolean add(E e) {
linkLast(e);
return true;
}
/**
* Links e as last element.
*/
void linkLast(E e) {
// 将原先的last指针指向的对象放到临时变量里
final Node<E> l = last;
// 创建一个新的节点对象,传入l节点作为新节点的前置节点
final Node<E> newNode = new Node<>(l, e, null);
// last指针指向新对象
last = newNode;
// 判断下,如果之前的节点为空,证明是空链表,这是第一次插入,将first指针指向新节点
if (l == null)
first = newNode;
else
// 原last指针指向的节点指向新的节点(新节点挂链到原链表上了)
l.next = newNode;
size++;
modCount++;
}
addLast(E e)和默认的add相同,实现里就一行代码,调用了linkLast方法
addFirst(E e)和addLast正好相反,是从头部插入数据
/**
* Links e as first element.
*/
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
// 链表个数+1
size++;
modCount++;
}
add(int index, E element)方法是将元素插入到指定的位置上:
- 首先,判断index是否在合法范围内
- 遍历链表找到index所在的节点,遍历的时候会判断index是在链表的前半部分还是后半部分来决定从first开始还是last开始
- 将新节点插入到index节点的前一个位置
- 将元素添加到任意两个元素的中间位置,添加元素操作只会改变前后元素的前后指针,指针将会指向添加的新元素,所以相比 ArrayList 的添加操作来说,LinkedList 的性能优势明显。
/**
* 指定位置的插入
*/
public void add(int index, E element) {
// 校验index是否合法
checkPositionIndex(index);
// 如果index刚好等于size,则直接尾插
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
/**
* 校验index是否合法
*/
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* 将新节点插入到当前节点(succ)的前一个位置上
*/
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev;
final Node<E> newNode = new Node<>(pred, e, succ);
succ.prev = newNode;
// 如果前置节点为空,代表是链表头了
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}
3.5 LinkedList查找元素
LinkedList查找元素和将新节点插入指定位置的逻辑是一样的,实际上将元素插入指定位置就是先查找到元素,再进行插入操作。同样,这里会先对index进行合法性校验,再通过index计算是从前向向后还是从后向前对链表进行遍历获取到对应数据
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
3.6 LinkedList删除元素
LinkedList提供了两种删除数据的方法,第一种是remove(int index),删除指定下标的元素,同查找元素逻辑一样,先遍历查找到index对应的下标节点,然后将这个节点的前置节点(prev)的next关联到这个节点的后置节点(next),将当前节点对应的属性值释放(赋值为null,便于JVM回收),这里要注意对边界值的处理
/**
* 删除指定下标的元素
*/
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
/**
* 删除指定下标的元素
*/
E unlink(Node<E> x) {
// assert x != null;
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
// 处理完后链表个数-1
size--;
modCount++;
return element;
}
另一个删除方法是remove(Object o),删除指定的元素,由于无法用index定位,所以这种删除方式只能每次动first开始遍历,将遇到的所有存的是指定元素值的节点全部删除,这里会对null进行特殊处理,如果入参为null的话就删除所有元素值为null的节点
public boolean remove(Object o) {
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
此外,LinkedList还提供了peek()和poll()系列方法,用来实现Queue的特性,这里就不展开论述了
四、总结
对比项 | ArrayList | LinkedList |
---|---|---|
实现接口 | 实现 List 接口,具有List类型特点 | 实现List 和 Deque接口,兼有List和Queue类型特点 |
克隆和序列化 | 可以实现 ✅ | 可以实现 ✅ |
随机快速访问 | 支持 ✅ | 不支持 ❌ |
元素遍历 | for循环效率更高 | 迭代器效率更高 |
数据结构 | 数组 (Object[] | 双向链表 (Node) |
扩容 | 扩容1.5倍 | 链表无需扩容 |
内存占用 | 连续的内存空间 | 不连续的内存空间,额外增加prev和next属性空间 |
写在最后 欢迎关注微信公众号【小肖爱吃肉】和你一起记录生活的小美好