Java集合 - List之LinkedList底层解析

 LinkedList简介

LinkedList是Java中Collection集合的实现类之一，底层由双向链表实现。

LinkedList继承关系

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

LinkedList类继承AbstractSequentialList(抽象类)，实现了List接口，Cloneable接口（克隆），Deque接口，Serializable接口（序列化）。

List接口继承了Collection接口，Collection接口继承了Iterable接口，故LindedList是Collection接口的实现子类，同样也是Iterable接口（迭代器）的实现子类，同时具有迭代器的方法。

LinkedList类同时也实现Queue接口，也就意味着LinkedList可以作为一个队列来使用。

LinkedList list = new LinkedList(3);
list.add(1);
list.add(2);
list.add(3);
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
	Object next = iterator.next();
	System.out.println(next);
}

LinkedList源码分析

重要的成员变量如下：

// 双向链表中元素的总数
transient int size = 0;

// 双向链表的头节点
transient Node<E> first;

// 双向链表的尾节点
transient Node<E> last;

// 静态内部类
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;
	}
}



从LinkedList的成员变量，总结如下：
1.LinkedList内部维护了一个头节点 和 一个尾节点
可以理解为一列火车的 车头 和 车位

2.维护了size，元素总数
相当于 一列火车的 车厢总数

3.静态内部类Node 就相当于 火车的一节车厢
	|- prev:前挂钩
	|- next:后挂钩
	|- E:乘客/货物

1.无参构造

/**
* 当调用LinkedList无参构造器时，只是初始化了一个LinkedList对象
*/
public LinkedList() {
    
}

2.有参构造

// LinkedList的有参构造器区别于ArrayList,Vector的有参构造器
// ArrayList,Vector的有参构造器,入参是一个int类型的初始容量值
// 而LinkedList的入参是一个Collection的集合
public LinkedList(Collection<? extends E> c) {
	// 调用自身无参构造器
	this();
	addAll(c);
}

public boolean addAll(Collection<? extends E> c) {
	// 调用重载方法，size就是双向链表存放元素的数量
	return addAll(size, c);
}

public boolean addAll(int index, Collection<? extends E> c) {
	// 校验index是否在[0,size]范围内
	checkPositionIndex(index);

	// 将集合转换为Object数组
	Object[] a = c.toArray();
	
	// 获取数组的长度
	int numNew = a.length;
	
	// 如果数组长度为0，说明集合为空集合，直接返回false
	if (numNew == 0)
		return false;
	
	// 声明两个Node
	Node<E> pred, succ;
	
	// 从上面的代码可以看出，index 等于 size
	if (index == size) {
	
	// pred 指向了 双向链表的尾节点
		succ = null;
		pred = last;
	} else {
		succ = node(index);
		pred = succ.prev;
	}
	
	// 遍历由集合转换的Object数组
	for (Object o : a) {
		@SuppressWarnings("unchecked") E e = (E) o;
		
		// 创建一个新节点Node，新节点的前挂钩，挂上pred（它现在是双向链表尾节点）
		Node<E> newNode = new Node<>(pred, e, null);
		
		// 如果双向链表的尾节点是null，说明双向链表是一个空链表
		if (pred == null)
		
		// 这个新节点就是双向链表的头节点
			first = newNode;
		else
		
		// 双向链表非空链表，那么尾节点的下一个节点就是这个新节点
			pred.next = newNode;
		// 注意：在新节点未挂钩之前，pred指向原来的尾节点；挂上双向链表之后，
		// 尾节点就要发生变化，新节点就变成了新的尾节点，因此pred的指向变更
		pred = newNode;
	}

	// 双向链表的尾节点指向pred
	if (succ == null) {
		last = pred;
	} else {
		pred.next = succ;
		succ.prev = pred;
	}

	// 数组遍历完成之后，意味着双向链表挂上了数组长度的火车车厢，因此链表的总数也需要同步增加
	size += numNew;
	// 修改次数加1
	modCount++;
	// 返回添加标识
	return true;
}

 private void checkPositionIndex(int index) {
	if (!isPositionIndex(index))
		throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

private boolean isPositionIndex(int index) {
	return index >= 0 && index <= size;
}

3.add(E e)方法

// LinkedList的add方法，返回值是一个boolean值：加入元素成功，返回true；否则返回false
public boolean add(E e) {
	linkLast(e);
	return true;
}

// 从方法的名字可以看出，LinkedList的add方法，是在链表的末尾添加元素
void linkLast(E e) {
	
	// 首先声明一个Node变量l，来存放last(双向链表的尾节点)
	final Node<E> l = last;
	
	// 然后创建一个新的Node节点，且新节点的 前/上节点指向l，新节点的item存放元素e，新节点的 后/下节点为null
	// 其实这个很好理解，新增的节点不就是 “挂”在原链表的“屁股”后面吗？
	// 因此新节点的 前/上节点不就是原链表的尾节点，新节点就变成了现在链表的“屁股”，故新节点的 后/下节点 自然是没有Node，即为null
	final Node<E> newNode = new Node<>(l, e, null);
	
	// 新节点就变成了现在链表的“屁股”，
	last = newNode;
	
	// 假设场景：在添加新节点之前，LinkedList中维护的尾节点是null，说明该双向链表是一个空链表
	// 那么新节点就是双向链表的头节点（只有它一个）
	if (l == null)
		first = newNode;
	else

	// 如果双向链表不是空链表，那么原来尾节点的下一个节点指向 新节点
		l.next = newNode;

	// 双向链表的节点数量加1
	size++;
	
	// 双向链表的修改次数加1
	modCount++;
}

4.addFirst(E e)方法

// addFirst方法，就是在双向链表的头节点新增一个节点
// 换句话说，更换 “车头”
public void addFirst(E e) {
	linkFirst(e);
}

private void linkFirst(E e) {
	
	// 声明一个Node变量指向双向链表的头节点
	final Node<E> f = first;
	
	// 创建一个Node节点，
	// 头节点的prev 为null（车头肯定是没有prev），
	// e为元素，
	// next为f（车头变更，意味着原来的头就变成了新车头的下一个节点）
	final Node<E> newNode = new Node<>(null, e, f);
	
	// 变更 “车头”
	first = newNode;
	
	// 如果“车头”为null，新节点就是“车尾”
	if (f == null)
		last = newNode;
		
	// 否则 车头的下一个节点就是新节点	
	else
		f.prev = newNode;
	
	// 车厢数量加1	
	size++;
	
	// 修改次数加1
	modCount++;
}

5.addLast(E e)方法

// addLast方法，就是在双向链表的尾节点新增一个节点
// 换句话说，更换 “车尾”
public void addLast(E e) {
        linkLast(e);
    }

private void linkLast(E e) {
	
	// 声明一个Node变量指向双向链表的尾节点
	final Node<E> f = last;
	
	// 创建一个Node节点，
	// 头节点的next 为null（车尾肯定是没有next），
	// e为元素，
	// next为f（车尾变更，意味着原来的尾就变成了新车尾的上一个节点）
	final Node<E> newNode = new Node<>(l, e, null);
	
	// 变更 “车尾”
	last = newNode;
	
	// 如果“车尾”为null，新节点就是“车头”
	if (f == null)
		first = newNode;
		
	// 否则 车尾的下一个节点就是新节点	
	else
		f.next = newNode;
	
	// 车厢数量加1	
	size++;
	
	// 修改次数加1
	modCount++;
}

6.getFirst()方法

public E getFirst() {

	// 获取车头
	final Node<E> f = first;
	
	// 车头为null，说明双向链表为空链表，抛异常
	if (f == null)
		throw new NoSuchElementException();
	
	// 返回车头的元素
	return f.item;
}

7.getLast()方法

public E getLast() {

	// 获取车尾
	final Node<E> l = last;
	
	// 车尾为null，抛异常
	if (l == null)
		throw new NoSuchElementException();
	
	// 返回车尾的元素
	return l.item;
}

LinkedList的特点

1.由于LinkedList底层是双向链表，同时也可以作为一个队列来使用。

2.add(E e)方法默认是从双向链表的末尾进行添加，所以时间复杂度为O(1)

3..LinkedList中的方法是非线程安全的，因此多线程环境下操作集合，不推荐使用LinkedList。