18.3 LinkedList（集合底层源码分析）

1.1.2 LinkedList

1）底层实现特点

特点：元素有序且可重复

底层实现：双向链表

2）什么是双向链表？

链表在内存中不是一串连续的地址，由一个一个节点组成，每个节点可以分为3部分（数据部分，头指针，尾指针）

优势：从中间插入和中间删除，只需要移动节点的指针指向，无需移动节点的位置

缺点：查询一个元素时，必须从头/尾依次往后/往前遍历

如何用Java代码实现一个双向链表？

3）LinkedList的源码解析

//双向链表的节点对象
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;

疑问为什么要做双向链表头指针和尾指针的引用？

因为没有这两个变量都找不到双向链表

添加元素的方法（add）

//添加元素
public boolean add(E e) {
    linkLast(e);
    return true;
}

//添加元素到链表的末尾
void linkLast(E e) {
        //让l变量指向last所指向的最后一个节点
        final Node<E> l = last;
    	//创建一个新的节点，数据部分就是新增的元素
    	//让新节点的头指针指向l
        final Node<E> newNode = new Node<>(l, e, null);
    	//将新节点赋值给last
        last = newNode;
        //判断当前是否添加的第一个元素
        if (l == null)
            //如果是第一个元素，那么newNode也要赋值给first
            first = newNode;
        else
            //如果不是，
            l.next = newNode;
        //元素个数++
        size++;
        modCount++;
    }

插入元素（add）

//插入元素到index的位置
public void add(int index, E element) {
        //检查下标是否越界
        checkPositionIndex(index);
        //判断index是否在末端
        if (index == size)
            //尾部的追加
            linkLast(element);
        else
            //插入
            //参数1：插入的元素
            //参数2：index位置的现有节点
            linkBefore(element, node(index));
    }

//获得index位置的元素
Node<E> node(int index) {
        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;
        }
    }

//将元素e，插入到节点succ的前面
void linkBefore(E e, Node<E> succ) {
        //succ的当前节点的上一个节点的指针的对象赋值给pred
        final Node<E> pred = succ.prev;
    //创建出一个新的节点，e代表元素部分，pred指向上一个节点，succ指向下一个节点
        final Node<E> newNode = new Node<>(pred, e, succ);
    //这个新的节点又指向succ的上一个指针（说明原先succ不指向上一个指针了而转向指向这个新的节点）
        succ.prev = newNode;
    //如果pred == null这就说明了succ是第一个节点，
        if (pred == null)
            //那么newNode就是第一个节点
            first = newNode;
        else
            //新节点指向了pred指向的下一个的指针
            pred.next = newNode;
        size++;
        modCount++;
    }

获得元素（get）

public E get(int index) {
    //下标越界
    checkElementIndex(index);
    //获得index位置的节点，方式同上，再返回节点的数据部分
    return node(index).item;
}

作业：自行查看remove方法的实现

1.1.3 ArrayList VS LinkedList性能分析

ArrayList查询速度很快，往中间插入/移除元素很慢。
LinkedList往中间插入/移除元素很快，查询元素很慢。

不确切

性能对比

插入性能对比：
尾部：ArrayList和LinkedList性能差异不大，几乎一样
头部：LinkedList性能 远远大于ArrayList性能，因为ArrayList需要进行数组的扩容 + 元素的位移（已经通过C优化）
中间：ArrayList性能 大于 LinkedList性能，原因在于LinkedList在插入中间位置时，需要查询中间的元素，LinkedList查询中间元素是最忙的操作

读取性能对比：
ArrayList：读取任何位置性能差异不大，速度很快
LinkedList：读取越靠中间的元素，性能越差，越靠两边，性能越好（ArrayList性能差不多）

1.1.4 HashSet、LinkedHashSet、TreeSet

1）特点

HashSet：无序，不可重复
LinkedHashSet：不可重复，有序（插入顺序）
TreeSet：不可重复，有序（字典序）

2）底层实现

Set集合的底层实现都是由Map集合实现的