Java容器LinkedList源码分析

LinkedList

LinkedList是List接口下的另一个实现类，ArrayList的特点是查询速度快，增、删慢，因为它底层是数组，增、删要进行数组复制，扩容操作。而LinkedList恰恰相反，它增，删，速度快，查询速度慢，底层是用双向链表实现。结构图如下：

双链表是一种线性结构。由多个节点组成。在LinkedList中定义成了一个内部类Node，有三个成员变量，用来表示一个节点。

item：用于存储数据
next：存储该节点的下一节点，如果没有则为null
prev:存储该节点的上一节点,如果没有则为null

    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这个类的成员变量也只有三个。

// 链表的元素的个数
transient int size = 0;
// 头节点
transient Node<E> first;
// 尾节点
transient Node<E> last;

1、get方法
获取第一个头点

	// 直接取出对象中的 first节点 然后返回
    public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }

获取尾节点

 public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }

根据索引index获取节点信息

    public E get(int index) {
    	//检查是否越界
        checkElementIndex(index);
        //根据index获取节点信息
        return node(index).item;
    }
	//从头结点或者尾节点开始遍历 
    Node<E> node(int index) {
    	//取出中间长度(size >> 1)   如果小于从头结点开始遍历寻找
        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;
        }
    }

2、add方法添加一个元素到list当中。

    public boolean add(E e) {
    	// 把节点插到链表最后 采用是尾插法
        linkLast(e);
        return true;
    }
        /**
     * Links e as last element.
     */
     
    void linkLast(E e) {
    	//未插入时的last节点
        final Node<E> l = last;
        //包装数据 new一个新的节点 设置该节点的上一个节点为last ,下一个节点为null，因为后面没有元素了
        final Node<E> newNode = new Node<>(l, e, null);
        // 将新的元素设置为链表的最后一个元素
        last = newNode;
        //如果最后一个元素为null 也就是第一次插入的时候
        if (l == null)
            first = newNode;
        else
        	//last的next指向 新节点
            l.next = newNode;
        size++;
        modCount++;
    }

指定位置插入一个元素在链表的指定位置插入一个元素，先应该遍历该节点，然后进行指针操作，如下图：

具体操作：next是下一个节点 pre是上一个节点
1、s—>next=p 对应4号操作
2、p—>pre—>next = s 对应5号操作
3、s—>pre = p—>pre 对应3号操作
4、p—>next = s 对应6号操作

    public void add(int index, E element) {
   		 // 检查越界
        checkPositionIndex(index);
		// 如果是插入最后一个元素，那么进行尾插法，等同于 直接添加一个元素
        if (index == size)
            linkLast(element);
        else
        	//在链表中间 指定位置插入一个元素 node(index), get到index的位置的元素。
            linkBefore(element, node(index));
    }
	
	// 在index位置元素上 插入Node节点
    void linkBefore(E e, Node<E> succ) {
        // succ 为index位置上是的元素
        final Node<E> pred = succ.prev;        
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode; 
        //当插入在0号位置 插入元素的时候
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }

3、remove方法 移除元素
移除元素通过index

    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;
		//判断 前驱是否为null 
        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }
		//判断后继是否为null 
        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

这里的删除，删除元素的位置有下面四种情况

1、删除a节点，a为链表的第一个 a的前节点指向null
2、删除b 节点，b的前后都不为null
3、删除c节点，c为最后一个节点
4、删除d节点，链表有且只有一个节点，该节点的前后都为null
记录一下删除b节点的过程，知道了这个，其余三种也都知道了

1、b->pre->next =b->next 1操作
2、b->next->pre=b->pre 2操作
3、b->pre =null 3操作
4、b->next = null 4操作
这样b节点 就与链表没有关联关系了。成功被删除