JAVA源码阅读之LinkedList基于JDK1.8

LinkedList是另一个实现List接口的集合实现类，他的主要特点和ArrayList相比是占用空间小，插入/删除/修改块，查询较慢，是一个双向链表的数据结构，既可以当成集合来使用，还可以当成队列Queue（双向队列），而且还可以做stack栈来使用;接下来一起来看下LinkedList的源码

目录

链表，队列，栈

类结构

类中的一些域

构造方法

链表结构方法

队列方法

栈结构方法

迭代器

总结

---

链表，队列，栈

这里先说下这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;
    }
}

LinkedList的节点是一个内部类，可以看到在该类定义一个指向下一个节点的 next变量，以及指向上一个节点的pre变量，以及当前节点的信息item。

 

类结构

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

LinkedList继承了AbstractSequentialList，AbstractSequentialList是一个只支持按次序访问的类，不支持随机访问,

实现了List接口，Cloneable,Serializable序列化接口，实现了Deque接口，这个Deque定义了队列和栈的操作方法，所以

LinkedList也有队列，栈数据结构的特性

 

 

类中的一些域

//维护当前列表集合的大小
transient int size = 0;
//维护第一个节点
transient Node<E> first;
//维护最后一个节点
transient Node<E> last;

LinkedList类中的域一共就只有3个，非常简单

 

构造方法

LinkedList类一共只有两个构造方法

public LinkedList() {}
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

可以看到构造方法比较简单 第二个方法会初始化链表的节点数据，通过addAll方法增加节点

 

 

链表结构方法

添加

public boolean add(E e) {
    //最终调用的是linkLast方法，这个方法是将节点添加到末尾
    linkLast(e);
    return true;
}

   

   再来看下 linkLast方法

void linkLast(E e) {
    //获得末尾节点
    final Node<E> l = last;
    //构造一个新的节点，置于末尾节点的下一位，成为新的末尾节点,新节点的pre引用指向上一个节点
    final Node<E> newNode = new Node<>(l, e, null);
    //维护末尾节点的引用，此时末尾节点是newNode 
    last = newNode;
    //如果添加新节点前 不存在末尾节点，那么将新节点作为首节点，如存在，上一个末尾节点的next引用要指    
    //向新的节点
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    //完成新节点前后的引用关系后 ，size自增1，列表大小加1
    size++;
    modCount++;
}

   可以看到这个方法是将新节点添加到链表末尾中去，判断了是否存在当前已存在节点，节点前后引用关系,后面很多其他方法都会调用到     此方法

  指定位置添加

public void add(int index, E element) {
    //判断是否越界 index不小于0且不大于size
    checkPositionIndex(index);
    //当前列表最后一项节点的index为size-1，如果index和size大小相等，则表示插入位置为末尾，调用                    
    //linkLast处理
    if (index == size)
        linkLast(element);
    else
    //调用linBefore进行位置插入处理，处理如下
    //index节点的上一个节点next指向插入的节点，index节点pre指向插入的节点
    //插入节点pre指向index节点的上一个节点，插入节点next指向index节点
        linkBefore(element, node(index));
}

   addAll(Collection<? extends E> c)以及addAll(int index, Collection<? extends E> c)思路类似，不贴出分析

 

 移除

public E remove(int index) {
    //判断是否越界 index不小于0且不大于size
    checkElementIndex(index);
    //调用unlink方法将找到的节点置位null，以便让jvm自行清理内存，处理前后节点的引用关系，
    return unlink(node(index));
}

 

  主要处理还是在unlink方法，通过链表的数据结构特性处理前后节点的引用关系

E unlink(Node<E> x) {
    
    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;
}

 

 移除对象的实现 通过遍历 找到第一个符合条件的节点，再调用unlink方法处理

public boolean remove(Object o) {
    if (o == 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;
}

 

  清除列表数据 遍历解除每个节点的前后引用关系和节点数据，维护first和last，size置位0

public void clear() {
    for (Node<E> x = first; x != null; ) {
        Node<E> next = x.next;
        x.item = null;
        x.next = null;
        x.prev = null;
        x = next;
    }
    first = last = null;
    size = 0;
    modCount++;
}

 

获取数据

public E get(int index) {
    //判断是否越界 index不小于0且不大于size
    checkElementIndex(index);
    //通过node方法取到该节点
    return node(index).item;
}

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

   这种查找方式优化了遍历的查找速度，遍历的次数减少

 

 

替换元素

public E set(int index, E element) {
     //判断是否越界 index不小于0且不大于size
    checkElementIndex(index);
    //通过node方法找到该节点
    Node<E> x = node(index);
    E oldVal = x.item;
    //替换节点中的元素信息
    x.item = element;
    return oldVal;
}

 

 

由于LinkedList实现的Deqeu接口，该接口定义了队列和栈结构特性的操作方法，所以可以通过LinkedList来实现队列或者栈的数据结构

 

队列方法

由于node节点结构是有双向引用的，所以该队列可以是双向队列，首尾两端都可以操作

添加到队列

//调用链表常规的add方法实现
public boolean offer(E e) {
    return add(e);
}
//调用链表常规的addFirst方法实现
public boolean offerFirst(E e) {
    addFirst(e);
    return true;
}
//调用链表常规的addLast方法实现
public boolean offerLast(E e) {
    addLast(e);
    return true;
}

 

移除出队列

移除出队列有两个方法实现，区别是有没有从链表中删除,队列的规则是先进先出，所以一般情况下取出的是首部的节点

当然，此队列有双向的特性，也提供了方法取出尾部的节点的方法,像peekFirst,peekLast,pollFirst,pollLast的方法

//只返回数据 不从链表中除去
public E peek() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
}
//返回数据 并从链表中除去
public E poll() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

 

 

栈结构方法

栈数据结构的特点是先进后出，也就是最后进入的可以优先被取出

添加到栈

public void push(E e) {
    addFirst(e);
}

可以看到这里添加到栈顶 调用的addFirst方法，所以栈顶的数据永远都处于链表的首部，即可得当从栈取数据时，取得也是首部的数据如下

从栈中移除

public E pop() {
    return removeFirst();
}

调用removeFirst移除并且返回了链表的首部节点数据

 

 

迭代器

每个集合类型都要实现它的迭代器，由于链表的节点结构持有上下节点的引用，所以迭代器不仅next方法，还有previous方法，

能够双向迭代,与其他集合的迭代器定义不一样，所以定义了一个继承于Iterator接口类的ListIterator接口，ListIterator接口

多定义了hasPrevious，previous，previousIndex，nextIndex方法

在LinkedList中定义了一个内部类实现ListIterator接口

private class ListItr implements ListIterator<E> {
        private Node<E> lastReturned;
        private Node<E> next;
        private int nextIndex;
        private int expectedModCount = modCount;

        ListItr(int index) {
            // assert isPositionIndex(index);
            next = (index == size) ? null : node(index);
            nextIndex = index;
        }

        public boolean hasNext() {
            return nextIndex < size;
        }

        public E next() {
            checkForComodification();
            if (!hasNext())
                throw new NoSuchElementException();

            lastReturned = next;
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }

        public boolean hasPrevious() {
            return nextIndex > 0;
        }

        public E previous() {
            checkForComodification();
            if (!hasPrevious())
                throw new NoSuchElementException();

            lastReturned = next = (next == null) ? last : next.prev;
            nextIndex--;
            return lastReturned.item;
        }

        public int nextIndex() {
            return nextIndex;
        }

        public int previousIndex() {
            return nextIndex - 1;
        }

        public void remove() {
            checkForComodification();
            if (lastReturned == null)
                throw new IllegalStateException();

            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
            if (next == lastReturned)
                next = lastNext;
            else
                nextIndex--;
            lastReturned = null;
            expectedModCount++;
        }

        public void set(E e) {
            if (lastReturned == null)
                throw new IllegalStateException();
            checkForComodification();
            lastReturned.item = e;
        }

        public void add(E e) {
            checkForComodification();
            lastReturned = null;
            if (next == null)
                linkLast(e);
            else
                linkBefore(e, next);
            nextIndex++;
            expectedModCount++;
        }

        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            while (modCount == expectedModCount && nextIndex < size) {
                action.accept(next.item);
                lastReturned = next;
                next = next.next;
                nextIndex++;
            }
            checkForComodification();
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

可以看到在构造函数中需要我们传入迭代的起始位置，并找到了起始位置的节点，这样方便我们可以进行不同方向的迭代数据

 

 

总结

LinkedList是基于双向链表实现的，由于双向链表的特性，所以具有插入/删除/修改块，查找慢，空间分配灵活，占用内存小的特点;由于实现了Deque的接口，基于LinkedList可以实现队列以及栈的结构。