List源码分析-LinkedList

说明：这个文章是我个人的学习笔记，由于本人水平有限，如果有什么误导的地方，请指正，谢谢

前提

• 对常用的集合进行复习分析，如，ArrayList、LinkedList、Vector

LinkedList

• UML图，LinkedList没有实现RandomAccess接口，说明它不能实现快速随机访问
  
• 基础属性

	transient int size = 0;

    // 是双向链表的头节点，它的前一个节点是 null。
    transient Node<E> first;

    // 是双向链表的尾节点，它的后一个节点是 null
    transient Node<E> last;

• LinkedList是基于双向链表数据结构实现的。
• LinkedList存储数据的内存地址是不连续的，是通过指针来定位不连续地址
• LinkedList没有实现RandomAccess接口，说明它不能实现快速随机访问
• 链表中每个节点Node，它有prev属性，代表前一个节点的位置，next属性，代表后一个节点的位置

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

下面来看看各个方法的解析

add()方法，新增元素，默认是将元素添加到队尾

• 把尾节点赋值临时变量l
• 新增一个节点e,前一个节点指向l,就是之前的最后一个节点，下一个节点为空
• 把last节点改成当前节点
• 如果链表为空，这次新增的为第一个节点
• 否则把前尾节点的的下一个节点指向当前新增节点

    public boolean add(E e) {
        linkLast(e);
        return true;
    }
	void linkLast(E e) {
		// 把尾节点赋值临时变量l
        final Node<E> l = last;
        // 新增一个节点e,前一个节点指向l,就是之前的最后一个节点，下一个节点为空
        final Node<E> newNode = new Node<>(l, e, null);
      	// 把last节点设为这次新增的节点
        last = newNode;
        if (l == null)
        	// 如果链表为空，这次新增的为第一个节点
            first = newNode;
        else
        	// 否则把前尾节点的的下一个节点指向当前新增节点
            l.next = newNode;
        size++;
        modCount++;
    }

add(int index, E element)方法，在指定位置插入元素

• 如果是最后一位，直接在列表最后追加
• 否则先找到当前index所在的节点（使用二分法查找）
• 在原来index节点前添加一个节点

public void add(int index, E element) {
        checkPositionIndex(index);
		// 如果是最后一位，直接在列表最后追加
        if (index == size)
            linkLast(element);
        else
        	// 否则在原来index节点前添加一个节点，就是当前新增的节点
            linkBefore(element, node(index));
    }

这里得先看看node方法，查找节点,这里并没有从头到尾循环查找，而是使用了一个简单的二分法的方式查找，根据index是在前半部分还是后半部分

	Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
        	// 查找前半部分，直到循环到index的前一个node停止
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
        	// 查找后半部分，直到循环到index的后一个node停止
            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;
	   // 由于 succ 一定不为空，所以可以直接获取 prev 节点为新增节点的上一个节点
	   final Node<E> pred = succ.prev;
	   // 新节点 prev 节点为 pred，next 节点为 succ（经过node方法返回的节点）
	   final Node<E> newNode = new Node<>(pred, e, succ);
	   // 原节点的prev指向新的节点
	   succ.prev = newNode;
	   // 如果 pred 为空即头节点出插入了一个节点，则将新的节点赋值给 first 索引
	   if (pred == null)
	       first = newNode;
	   else
	       pred.next = newNode;//否则 pred 的下一个节点改为新节点
	   size++;
	   modCount++;
	}

删除元素

• 删除首位元素

private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        // 用作返回
        final E element = f.item;
        // 头节点的下一节点
        final Node<E> next = f.next;
        // 释放节点内容和next ，等待GC
        f.item = null;
        f.next = null; // help GC
        // 下一个节点作为新的首节点
        first = next;
        if (next == null)
        	// 如果next为空，说明链表只有一个节点，last 指向 null
            last = null;
        else
        	//否则 next 的 prev 指针指向 null，因为首节点prev为空
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

• 删除末尾元素

private E unlinkLast(Node<E> l) {
        // assert l == last && l != null;
        final E element = l.item;
        // 尾节点的上一节点
        final Node<E> prev = l.prev;
        // 释放节点内容和prev ，等待GC
        l.item = null;
        l.prev = null; // help GC
        // 上一个节点为新的尾节点
        last = prev;
        if (prev == null)
        	// 链表只有一个节点的时候，first 指向 null
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

• 删除指定节点，就是重新绑定原来前节点的后节点，原来后节点的前节点

E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        // 临时变量，index节点原来的前后节点
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;
		
        if (prev == null) {
        	// 如果节点为头节点 则first节点设为index的下一个节点
            first = next;
        } else {
        	// 将index上一个节点的next直接指向index下一个节点
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
        	// 如果节点为尾节点 则last节点设为index的上一个节点
            last = prev;
        } else {
        	// 否则将index后一个节点的prev直接指向index上一个节点
            next.prev = prev;
            x.next = null;
        }

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

• 查询节点get,就是上述上的根据node方法返回的节点
• 修改节点，这个方法就比较简单了，就是修改节点里面的item元素就行了

总结

• 集合底层实现的数据结构为双向链表
• 集合中的元素可以为null和重复元素
• 非线程安全
• 因为查找元素需要遍历集合，所以查找元素效率会比较慢