Java中的集合之LinkedList,Queue

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_28666193/article/details/85257889

讨论集合关注的问题：

1. 底层数据结构
2. 增删改查方式
3. 初始容量，扩容方式，扩容时机
4. 线程安全与否
5. 是否允许空，是否允许重复，是否有序

我们都知道Collection接口派生出三大类的子接口List，Set和Queue。今天继续看List这个系列下的LinkedList，关于ArrayList和Vector前篇已经讲过。

Java集合之ArrayList，Vector和Stack

LinkedList和ArrayList都属于List集合的“范畴”，很大程度上与LinkedList的使用方式类似，区别主要在底层的实现上。顾名思义，LinkedList其底层采用了链表的方式来维护集合中的数据。而Queue队列，是3大类中比较特殊的一类，其子类较少，一般和其他的集合中进行关系的维护。例如LinkedList中就使用了一个双向队列。

LinkedList

LinkedList是一个List接口的“范畴”，我这里说的并不准确，但是一般在开发中采用的“接口+实现类”的方式中，就经常使用List接口来指向其被实现的类，这样大部分的增删改查的操作方法都可以使用自List接口的调用。

LinkedList继承自AbstractSequentialList（AbstractList的子类）类，实现了List, Deque, Cloneable, Serializable,说明LinkedList可以进行克隆和序列化操作，其在序列化时，会序列化所有的非空数据。

LinkedList使用一个头结点first，一个尾节点last，和一个内部类Node来维护集合中的数据，Node是一个具有前后指针的节点结构，来完成链表的双向操作。

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

添加新的元素时，默认添加到链表的末尾。同样可以指定添加的位置，都需要通过first指针一直遍历下去，知道找到合适的位置。添加元素主要是linklast和linkbefore两个方法：

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

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }	
	void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }
    /**
     * Inserts element e before non-null Node succ.
     */
    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);
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }

在LinkedList中删除元素时，同样需要通过循环遍历链表的指针，找到对应的节点后释放，相比于ArrayList这个操作仅需修改和释放(unlink)指针即可，不需要涉及内容的复制。使用Clear将依次遍历指针节点，置为Null.

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;
    }
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实现了Deque接口，通过双向指针的节点，能够实现双向队列的操作；可以获取头尾元素，将元素插入头或者尾部。值得注意的是，LinkedList中的push方法，是将新元素添加到集合的头部。

	public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
     }

    /**
     * Retrieves, but does not remove, the last element of this list,
     * or returns {@code null} if this list is empty.
     * @since 1.6
     */
    public E peekLast() {
        final Node<E> l = last;
        return (l == null) ? null : l.item;
    }
    public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
    public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }
    public void push(E e) {
        addFirst(e);
    }
    public E pop() {
        return removeFirst();
    }

---

Queue

所谓队列，可以和Stack进行对比，是先进先出或者说后进后出的一种数据结构。在Java集合中，示例UML图如下，图片来源

一般而言，队列下实现了一个双向队列Deque，其被其他集合如上面的LinkedList中继承而去，主要是实现了链表的一些双向操作的可实施性；另一方面，ArrayDeque主要是使用数组来实现双向队列的操作的。还有一类不太常用的优先队列类。这两类都是非线性安全的。

ArrayDeque

ArrayDeque通过一个transient修饰的数组和头尾指针实现，同样实现了Cloneable, Serializable接口。其初始容量为16。

循环数组：这里队列中控制容量大小时2的幂次，每次添加一个元素时，和数组长度做一次与（&）运算，进行判断是否需要扩容。

public void addFirst(E e) {
        if (e == null)
            throw new NullPointerException();
        elements[head = (head - 1) & (elements.length - 1)] = e;
        if (head == tail)
            doubleCapacity();
    }
    /**
     * Inserts the specified element at the end of this deque.
     * @throws NullPointerException if the specified element is null
     */
    public void addLast(E e) {
        if (e == null)
            throw new NullPointerException();
        elements[tail] = e;
        if ( (tail = (tail + 1) & (elements.length - 1)) == head)
            doubleCapacity();
    }

PriorityQueue

优先队列存在一个优先级的概念，不遵循FIFO规则。每次按照优先级最高的数据取出；优先队列内部维护着一个堆，每次取数据的时候都从堆顶拿数据（堆顶的优先级最高），这就是优先队列的原理。

---

总结：

• LinkedList和Queue（ArrayDeque/PriorityQueue）都是非线性安全的
• LinkedList采用链表数据结构维护，在删除或插入元素时不需要进行数组的复制，节省内存；但是不支持随机访问，需要通过遍历指针来查找。不过，因其底层是一个双向链表，可以方便的对头尾进行操作。
• ArrayQueue使用数组进行数据维护，PriorityQueue使用堆进行数据维护。