LinkedList浅析

LinkedList是一个双向链表的数据结构，通过链表的特性对数据串联，下面对源码进行分析，首先看下类的关系图：

通过图对LinkedList的继承和实现关系有个大体的了解。

自身维护属性

• size ：链表的大小；
• Node first ：头节点；
• Node last ：尾节点；
  Node节点主要是通过next、prev两个指针将List串联起来的，item当前节点值。

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

对于构造方法忽略不说了，直接看常用的add、set、get方法；

add分析

• add(E e)

添加数据时直接将数据放到链表的尾部，先判断last节点是否为null，若是则无数据将新插入的元素作为首节点，否则放到链尾。

public boolean add(E e) {
		//往下看
        linkLast(e);
        return true;
}
void linkLast(E e) {
		//拿出尾节点
        final Node<E> l = last;
        //新添加元素并将l设置为新元素prev节点
        final Node<E> newNode = new Node<>(l, e, null);
        //将新节点置为尾节点
        last = newNode;
        //判断l是否为null，若为null则表示链表为空，新元素节点即为首节点，否则置为尾节点
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

操作完成后返回true表示添加成功。

• add(int index, E element)

将元素添加到指定位置，添加到链表尾部还是之前的区别。

public void add(int index, E element) {
		//检查指定位置是否在List范围内，往下看代码
        checkPositionIndex(index);
        if (index == size)
        	//指定位置为当前链表大小，则添加到链表尾部与add(E e)一样
            linkLast(element);
        else
        	//往下看代码
            linkBefore(element, node(index));
}
private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
}

linkBefore涉及到两步操作，1、从指定位置提取出节点，2、针对提取的节点与新元素进行链表的串联操作。

Node<E> node(int index) {
        // assert isElementIndex(index);
		//当index小于size的一半时，则从首节点开始循环index次拿到节点
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
        	//做大于size一半且小于size则从尾节点开始选好index次直到拿到节点
            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;
        将指定位置节点的prev节点取出
        final Node<E> pred = succ.prev;
        //创建新元素节点，将pred作为新节点的前节点，succ作为新节点的下一个节点
        final Node<E> newNode = new Node<>(pred, e, succ);
        //设置指定位置节点的prev为新节点
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
        	//替代succ节点
            pred.next = newNode;
        size++;
        modCount++;
}

图中说明的是linkBefore的一个过程，首先是succ的prev节点是pred，而pred的next节点是succ，最初的链表顺序（蓝色箭头），新元素创建节点时将newNode的prev节点置为pred，next节点置为succ，至此完成部分链表的串联（红虚线），最后将succ的prev节点置为newNode，pred的next节点置为newNode（绿色箭头，打叉的地方表示已经消除）

set分析

set实际上是重置指定位置的元素，并返回旧值。

public E set(int index, E element) {
		//检查index是否越界
        checkElementIndex(index);
        //跟add(int index, E element)一样，获取指定位置的元素
        Node<E> x = node(index);
        //获取元素值
        E oldVal = x.item;
        //用新值覆盖旧值
        x.item = element;
        //返回旧值
        return oldVal;
}

get分析

代码比较简单获取指定位置元素值，采用的是node与上边分析的逻辑是一样的，判断是否越界，获取指定位置元素值。

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

总结

本文只是分析了常用的几个方法，LinkedList的特点是无界的可以一直添加，LinkedList在添加和删除节点是效率较高，但是在查找时效率较低需要遍历节点才能找到。