概括
LinkedList见名知意，底层由链表实现，内存不连续
增删快，查改慢（相对而言），不支持随机访问（没有实现RandomAccess接口）
非线程安全，用 Collections.synchronizedList(new LinkedList<>())
类继承关系图
既可以用作链表，也可以用作队列和双端队列，还可以用作栈
复杂度
get(int index) 需要从first开始遍历，复杂度O(n)
add(E e) 添加到末尾，调用的linkLast(E e)，复杂度O(1)
add(index, E) 在第几个元素的位置添加新元素，调用的是linkList或linkBefore，复杂度O(n)
remove(int index) 和 remove(Object o) 删除元素，复杂度O(n)
源码
类说明翻译
/** * Doubly-linked list implementation of the {@code List} and {@code Deque} interfaces. Implements all optional list operations, and permits all elements (including {@code null}). * 双向链表List（这里已经告诉你它的实现是 Doubly-linked） 实现了 List 和 Deque接口，实现了list 接口的所有操作，允许包括null在内的所有的值 * All of the operations perform as could be expected for a doubly-linked list. Operations that index into the list will traverse the list from the beginning or the end, whichever is closer to the specified index. * 它的所有操作都符合对双向链表的预期 ,关于index(下标，或者是索引)的操作都会从头或者从尾部遍历整个链表，直到遍历到这个下标 * Note that this implementation is not synchronized * If multiple threads access a linked list concurrently, and at least one of the threads modifies the list structurally, it must be synchronized externally.
* (A structural modification is any operation that adds or deletes one or more elements; merely setting the value of an element is not a structural modification.)
* This is typically accomplished by synchronizing on some object that naturally encapsulates the list. * 上面这一段是说它不是线程安全的，如果多个线程并发访问一个链表，并且至少一个线程要做结构性修改（结构性修改是指增删一个或多个元素的操作，仅仅对一个元素的值做修改不是结构性更改）,那么需要在对它操作之前，增加同步手段来控制对它的访问，比如对象加锁的方式 * If no such object exists, the list should be "wrapped" using the {@link Collections#synchronizedList Collections.synchronizedList} method.
* This is best done at creation time, to prevent accidental unsynchronized access to the list:
* <pre> List list = Collections.synchronizedList(new LinkedList(...));</pre> * 如果没有这样的可加锁的对象，可以使用LinkedList 的包装类对象，也就是调用List list = Collections.synchronizedList(new LinkedList(...))来创建包装类对象来创建一个线程安全的链表 * <p>The iterators returned by this class's {@code iterator} and {@code listIterator} methods are <i>fail-fast</i>:
* if the list is structurally modified at any time after the iterator is created, in any way except through the Iterator's own {@code remove} or {@code add} methods,
* the iterator will throw a {@link ConcurrentModificationException}. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than * risking arbitrary, non-deterministic behavior at an undetermined time in the future. * 这一段讲的是快速失败的特性，以及如何避免，和ArrayList相似，下面是说快速失败机制不应该用来设计程序编码，只是用来排查bug的 * <p>Note that the fail-fast behavior of an iterator cannot be guaranteed * as it is, generally speaking, impossible to make any hard guarantees in the * presence of unsynchronized concurrent modification. Fail-fast iterators * throw {@code ConcurrentModificationException} on a best-effort basis. * Therefore, it would be wrong to write a program that depended on this * exception for its correctness: <i>the fail-fast behavior of iterators * should be used only to detect bugs.</i> * @author Josh Bloch * @see List * @see ArrayList * @since 1.2 * @param <E> the type of elements held in this collection */
主要属性
transient int size = 0; /** * Pointer to first node. ----------first的prev一定是null * Invariant: (first == null && last == null) || ------就是说first==null的话，那么last一定也是null，因为first==null，则这个链表就是一个空链表，没任何元素;所以只要出现if(first==null)的话，一定要给last赋同一个新node值 * (first.prev == null && first.item != null)------ 如果first的prev为null,说明first一定是有元素的，item一定不为null */ transient Node<E> first; /** * Pointer to last node. ----------last的next一定是null * Invariant: (first == null && last == null) || * (last.next == null && last.item != null) */ transient Node<E> last; 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; } }
几个多次用到的公共方法
- 返回指定索引位置的Node
这个方法在源码多个位置被调用到，而且充分利用到了双向链表的特性，根据index和size/2的大小关系决定从前还是从后遍历
Node<E> node(int index) { // assert isElementIndex(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; } }
作为队列和栈时的主要方法
Queue操作： E peek() 返回head(就是first.item).相似的一个方法是E element(),head不存在时直接抛异常，所以这个方法可以忽略 E poll() 删除并返回head。E remove()相同，可能抛出异常，所以忽略 boolean offer(E e),调用的是add(),添加元素作为tail(也就是last) Dequeue操作 E peekFirst()，E peekLast() E pollFirst()，E pollLast() boolean offerFirst(E e)，boolean offerLast(E e) Stack操作 void push(E e) 调用的是addFirst(e) E pop()
遍历的最佳方式
前面复习ArrayList的时候已经讲过了，不支持随机访问的情况下，当然是迭代器遍历最快了，实验数据很简单
和ArrayList的对比
实现原理，性能（从存和取，结构修改三个角度）