源码学习——LinkedList

源码学习——ArrayList

前言

将常用的步骤解释的较为详尽易懂，若有错误麻烦指正。个人认为甚至些许啰嗦，建议有基础的同学直接看源码，源码更为直接了当易懂，且不会产生语句上的歧义。

继承关系

UML 图示

• 实现 List 接口，属于列表类
• 实现 Deque 接口，属于一个双端队列
• 实现 Cloneable 接口，可以重写 Object.clone() 方法，具有深度克隆的能力。

内部节点类

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;
    }
}

成员变量

/**
 * 链表中节点数目
 */
transient int size = 0;

/**
 * 指向链表的首节点的指针
 */
transient Node<E> first;

/**
 * 指向链表的尾节点的指针
 */
transient Node<E> last;

构造方法

无参构造，空空如也

public LinkedList() {
}

传入一个集合，初始化空链表，将集合元素全部加进去

public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

addAll 留在后面讨论

添加

添加到末尾

public boolean add(E e) {
    linkLast(e);
    return true;
}

void linkLast(E e) {
	// 当前链表的末尾节点
    final Node<E> l = last;
    // 将末尾节点作为前级，后继为 null
    final Node<E> newNode = new Node<>(l, e, null);
    // 末尾节点指向当前节点
    last = newNode;
    if (l == null)
    	// 链表为空，头节点也是当前节点
        first = newNode;
    else
    	// 当前节点成为原末尾节点的后继节点
        l.next = newNode;
    size++;
    // 列表结构发生变化
    modCount++;
}

插入到指定位置

public void add(int index, E element) {
	// 检查要插入的 index 边界问题
    checkPositionIndex(index);

    if (index == size)
    	// 插入索引为 size，直接连接在末尾
        linkLast(element);
    else
    	// 查出目前 index 的节点
    	// 将当前元素连接到该节点的前面
        linkBefore(element, node(index));
}

检查要插入的 index 边界问题

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

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

查找 index 索引处的节点

• 索引值小于总长度的一半，从头到尾查
• 索引值大于总长度的一半，从尾到头查

Node<E> node(int index) {
    // assert isElementIndex(index);
	// size >> 1 ， size 的一半
    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;
    }
}

将目标元素连接到指定节点前面

如果觉得关系乱，画图很容易理解

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++;
}

添加一个集合

// 添加一个集合
public boolean addAll(Collection<? extends E> c)
// 从某个索引开始，添加一个集合
public boolean addAll(int index, Collection<? extends E> c)

这两个方法与添加一个元素相差无几，只是数量上的改变，可自行参阅源码

删除

删除一个元素

区分删除的元素是否为 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;
}

将当前节点的前后连接关系接触

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;
        // help gc
        x.prev = null;
    }
	
    if (next == null) {
    	// 后继为空，当前节点为尾，让其前级代替
        last = prev;
    } else {
    	// 后继的前级为当前前级
        next.prev = prev;
        x.next = null;
    }
	// help gc
    x.item = null;
    size--;
    modCount++;
    return element;
}

删除目标索引的元素

public E remove(int index) {
	// 检查边界
    checkElementIndex(index);
    // 找到目标索引的节点，解除连接关系
    return unlink(node(index));
}

查看

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

修改

public E set(int index, E element) {
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

双端队列相关

主要还是围绕头节点和尾节点的连接和解除连接操作，可自行阅读源码。

LinkedList 和 ArrayList 的区别

• 底层数据结构的区别，一个基于动态数组，一个基于链表。
• 上述区别使得随机访问元素的形式不同，ArrayList 可以通过数组下标随机访问数组元素，可以实现 RandomAccess 接口；LinkedList 只能使用迭代器进行访问。
• 新增和删除元素，ArrayList 可能需要扩容，LinkedList 不需要。
• 空间浪费的体现不同，ArrayList 需要留足够的容量方便插入，LinkedList 需要维持链表间的关系和对象开销。

源码学习——ArrayList