LinkedList学习

我们还是看源码，来了解LinkedList。

添加结点

我们先看add（E e）方法

 public LinkedList() {//这是没有参数的构造方法，什么都没有执行
    }

public boolean add(E e) {
        linkLast(e); //进入这个方法，根据方法名可以猜测是往后添加新添加的元素
        return true;
    }

void linkLast(E e) {
        final Node<E> l = last; //第一次添加last为null，l也为null。这个last会随着添加的结点往后移，总是指向最后一个结点
        final Node<E> newNode = new Node<>(l, e, null);//这个就是存储元素的结点了，第一次其实prev和next都指向null
        last = newNode; //最后的结点指向含有新添加元素的结点（第一次添加元素其实last为null）
        if (l == null)//第一次进入这个分支
            first = newNode;//first指向含有新添加元素的结点，其实第一次last和first指向的是同一个结点
        else
            l.next = newNode;//后面的就是最后一个结点的next指向新添加的结点，而新结点的prev已经在Node的构造函数中指向了此时的last（就是还没有添加新结点的最后一个结点）
        size++; // 这个size就是统计结点的个数
        modCount++;  //又看到这个，说明LinkedList是线程不安全的。
    }

transient Node<E> last;

private static class Node<E> { //这个为存储元素的结点内部类
        E item; //元素
        Node<E> next;  //下一个结点
        Node<E> prev;   //前一个结点
//看到这里，所以可以得出LinkedList是基于双向链表的。
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next; //这个next其实总是指向null，因为这个结点顺序添加后为最后一个结点（调用add（E e）方法）
            this.prev = prev;
        }
    }

所以加上这个，就清楚地知道linkedlist调用add（E e）方法，发生了什么。就是基本的双向链表往最后面加结点的实现。

查找结点

我们再看一下get（index）方法。

public E get(int index) {
        checkElementIndex(index);//检查下标是否合法，这里就用到了size变量
        return node(index).item;//我们进入这个方法
    }
	private void checkElementIndex(int index) {
	    if (!isElementIndex(index))
	        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
	}
	private boolean isElementIndex(int index) {
        return index >= 0 && index < size;//size在这
    }

我们看一下node（index）这个方法。

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

        if (index < (size >> 1)) {//如果index小于结点个数/2
            Node<E> x = first;//找到第一个结点
            for (int i = 0; i < index; i++)//从第一个结点往第index个结点找（往后找）
                x = x.next;
            return x;
        } else {  //否则
            Node<E> x = last; //找到最后一个结点
            for (int i = size - 1; i > index; i--) //从最后一个结点往第index个结点找（往前找），
                x = x.prev;
            return x;
        }
    }

这样就减少了一半的查找量。双向链表的好处体现出来了,即减少了一半的查找量。

插入结点

我们看一下add（index，E e）方法。

public void add(int index, E element) {
        checkPositionIndex(index);//检查index

        if (index == size) //如果index==size，即往最后一个结点的后面插，和add（E e）方法一样了
            linkLast(element);
        else
            linkBefore(element, node(index));//否则进入这个方法，node（index）返回第index个结点
    }

我们看一下linkBefore这个方法。

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);//这里新结点的prev和next都已经指向了前面的和后面的结点
	        succ.prev = newNode;//原本index位置上的结点的prev指向新结点
	        if (pred == null)//如果要插入位置的prev为null，则表明新插入的结点将会是第一个结点，
	            first = newNode;//first总是指向第一个结点
	        else
	            pred.next = newNode;//否则前一个结点的next指向新结点，
	        size++;
	        modCount++;
	    }

就是相当于一个双向链表的插入。

删除结点。remove（Object o）

public boolean remove(Object o) {
        if (o == null) {  //说明linkedlist可以插入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;
    }

我们看一下unlick（x）方法。

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;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

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

所以我们可以看到对于LinkedList是基于双向链表的，插入、删除都是很快的，但查找就没有ArrayList快了（是查找一半）。他也是非线程安全的，可以插入null。