一、基本图示

二、基本介绍

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

结构

• LinkedList 继承 AbstractSequentialList 抽象类，该类是只支持按次序访问
• LinkedList 实现了 List 接口
• LinkedList 实现了 Deque 接口，即能被当作双端队列
• 实现了 Cloneable 接口，覆盖了 clone 方法，即可以被克隆
• 实现了 Serializable 接口，支持序列化

特性

• 底层使用链表，还是双向链表
• 元素是有序的，输入顺序和输出顺序一致
• 是线程不安全的
• 可以添加元素 null，可以添加相同的元素

三、双向链表的基本结构

因为底层是双向链表，因此所有成员变量都和链表的属性有关

// 链表的长度 transient int size = 0; // 头节点 transient Node<E> first; // 尾节点 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; } } 

四、内部调用的方法

因为在调用增加、删除、修改方法的时候，都是直接调用这几个方法，因此就直接来看这几个方法。包括

• void linkFirst(E e)：把数值插入到链表头部
• void linkLast(E e)：把数值插入到链表尾部
• void linkBefore(E e, Node<E> succ)：在指定节点前面插入值(节点不为空)
• E unlinkFirst(Node<E> f)：删除不为空的头节点，返回删除的值
• E unlinkLast(Node<E> l)：删除不为空的尾节点，返回删除的值
• E unlink(Node<E> x)：删除不为空的指定节点
• Node<E> node(int index)：返回指定位置的节点

// 把数据插入到链表头部 private void linkFirst(E e) { // 获取当前链表的头节点 final Node<E> f = first; // 创建一个节点，向前指向 null，向后指向当前链表的头节点 f final Node<E> newNode = new Node<>(null, e, f); // f 指向新的节点 first = newNode; // 如果 f 为空(添加之前什么也没有)，则链表的尾节点也指向新建节点 // 此时链表的头节点和尾节点都指向这个新创建的节点 if (f == null) last = newNode; // 如果 f 不为空(添加之前头节点已经有了)，原来的头节点向前指向新的节点 else f.prev = newNode; size++; modCount++; } // 把数据插入到链表尾部 void linkLast(E e) { // 获取当前链表的尾节点 final Node<E> l = last; // 创建一个节点，向前指向该链表的尾节点，向后指向 null final Node<E> newNode = new Node<>(l, e, null); // 将 l(之前的尾节点) 指向新的节点 last = newNode; // 如果 l 为空，则链表的头节点也指向该新节点，此时链表的头和尾节点都指向该节点 if (l == null) first = newNode; // 如果 l 不为空(链表不为空)，则原来的尾节点向后指向新创建的节点 else l.next = newNode; size++; modCount++; } // 在指定节点前面插入值，这里假设指定节点不为空 void linkBefore(E e, Node<E> succ) { // 获取指定节点的前一个节点 final Node<E> pred = succ.prev; // 创建一共新节点，向前指向 succ 节点的前一个节点，向后指向 succ 节点，数值是 e final Node<E> newNode = new Node<>(pred, e, succ); // succ 向前指向新建的节点 succ.prev = newNode; // 如果 succ 前面的节点为空，则新建的节点就是第一个节点 if (pred == null) first = newNode; // 如果 succ 前面的节点不为空，则用 succ 节点向后指向新建的节点 // 此时代表插入完成 else pred.next = newNode; size++; modCount++; } // 删除不为空的头节点，返回删除节点的值 private E unlinkFirst(Node<E> f) { // 获取头节点的数据 final E element = f.item; // 获取头节点的后面一个节点 next final Node<E> next = f.next; // 将头节点的数据置空 f.item = null; // 将头节点向后指向 null f.next = null; // 此时后面一个节点变为头节点 first = next; // 如果头节点向后指向 null，即原本链表中就这一个节点，移除后链表中就没有节点了 if (next == null) last = null; // 如果头节点后面还有节点，那么删除的头节点就指向 null else next.prev = null; size--; modCount++; return element; } // 删除不为空的尾节点，返回删除节点的值 private E unlinkLast(Node<E> l) { // 获取尾节点的数值 final E element = l.item; // 获取尾节点的前面一个节点 prev final Node<E> prev = l.prev; // 将尾节点的置空 l.item = null; // 将尾节点向前指向 null l.prev = null; // 此时前面一个节点变为链表的尾节点 last = prev; // 如果尾节点的向前指向 null，即链表本来就只有这一个节点，移除后链表中就没有节点了 if (prev == null) first = null; // 如果尾节点前面还有节点，则向后指向 null else prev.next = null; size--; modCount++; return element; } // 删除指定不为空的节点，返回节点对应的值 E unlink(Node<E> x) { // 获取要删除节点的值 final E element = x.item; // 获取删除节点后面的节点 next，前面的节点 prev final Node<E> next = x.next; final Node<E> prev = x.prev; // 如果要删除的节点前面没有节点，说明是第一个节点 if (prev == null) { // 此时删除节点后面的那个节点变成头节点 first = next; // 如果要删除的节点不是第一个 } else { // 让要删除节点的前一个节点向后指向要删除节点的后一个节点，即直接跨过要删除的节点 prev.next = next; // 同时向前指向 null x.prev = null; } // 如果要删除节点后面没有节点，说明是最后一个节点 if (next == null) { // 此时删除节点前面那个节点变为尾节点 last = prev; // 如果要删除的节点不是最后一个节点 } else { // 让要删除节点的后一个节点向前指向要删除节点的前一个节点，还是跳过要删除的节点 next.prev = prev; // 同时向后指向 null x.next = null; } // 将要删除的节点的值置空 x.item = null; size--; modCount++; // 返回删除的节点 return element; } // 获取指定位置的节点 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; } } 

需要注意 Node<E> node(int index) 方法，该方法会在后面的查找和删除等方法中用到，它的作用在于，是根据你传入的位置来判断是从链表的前面还是后开始查找，当传入位置小于长度的一半时，从前向后查找；否则，从后向前查找

五、添加方法

在指定位置进行插入的时候，会先调用 node(int index) 方法判断该位置是在集合长度的一半之后还是之后，如果小于长度一半则从前向后寻找位置，然后添加元素；否则，从后向前寻找位置，然后添加

// 在集合尾部添加元素 public boolean add(E e) { linkLast(e); return true; } // 在集合的指定位置添加值 public void add(int index, E element) { checkPositionIndex(index); // 如果插入位置正好是集合最后一位的后一位 if (index == size) // 则在链表最后添加 linkLast(element); else // 否则先根据位置确定对应的元素 // 然后把指定值插入到该元素的前面 linkBefore(element, node(index)); } // 在指定位置插入一个集合 public boolean addAll(int index, Collection<? extends E> c) { checkPositionIndex(index); // 将传入的集合转为 Object 数组 Object[] a = c.toArray(); int numNew = a.length; if (numNew == 0) return false; // 定义两个节点，pred 是插入位置的前一个节点，succ 是插入位置的后一个节点 Node<E> pred, succ; // 直接将集合插入到最后 if (index == size) { // succ 没什么用，直接置空 succ = null; // pred 用来保存每插入一个元素的位置 pred = last; // 如果集合不是插入到尾部 } else { succ = node(index); pred = succ.prev; } // 遍历集合数组 for (Object o : a) { @SuppressWarnings("unchecked") E e = (E) o; // 创建新节点，向前指向 pred Node<E> newNode = new Node<>(pred, e, null); // 如果 pred 为空，表明新建的节点是头节点 if (pred == null) first = newNode; else pred.next = newNode; // pred 保存最后一个新建节点的位置 pred = newNode; } // 如果 succ 是 null，说明集合是直接插入到尾部的 if (succ == null) { // 此时插入的最后一个元素便是尾节点 last = pred; // 否则，将插入的最后一个元素和插入位置的后一个节点相连接 } else { pred.next = succ; succ.prev = pred; } size += numNew; modCount++; return true; } // 将集合直接插入到尾部 public boolean addAll(Collection<? extends E> c) { return addAll(size, c); } // 在集合头部插入元素 public void addFirst(E e) { linkFirst(e); } // 在集合尾部插入元素 public void addLast(E e) { linkLast(e); } 

六、删除方法

主要包括三种

• 按照位置删除
• 按照指定元素删除(如果重复则只删除第一次出现的那个元素)
  • 从前往后寻找
  • 从后往前寻找
• 删除第一个或最后一个元素

如果从指定位置删除对应的元素，也会先判断位置然后再进行对应的操作，这一点和增加操作一样

// 删除集合中的第一个元素 public E remove() { return removeFirst(); } // 删除集合中指定位置的节点 public E remove(int index) { checkElementIndex(index); // 先使用 node(int index) 方法找到指定位置的节点 // 调用 unlink(Node<E> x) 删除该节点 return unlink(node(index)); } // 删除集合中指定的元素(如果集合中有不止一个，则只删除前面一个) public boolean remove(Object o) { // 如果指定元素为 null if (o == null) { // 遍历链表中的元素 for (Node<E> x = first; x != null; x = x.next) { // 只要遍历到 null，删除并返回 true 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; } // 删除第一个头节点，返回删除的元素 public E removeFirst() { final Node<E> f = first; if (f == null) throw new NoSuchElementException(); return unlinkFirst(f); } // 删除最后一个节点，返回删除的元素 public E removeLast() { final Node<E> l = last; if (l == null) throw new NoSuchElementException(); return unlinkLast(l); } // 删除指定元素(从前往后如果有相同的则只删除第一次出现的)，就是 remove(Object o) 方法 public boolean removeFirstOccurrence(Object o) { return remove(o); } // 删除指定元素(从后往前如果有相同的则只删除第一次出现的)，就是倒置的 remove(Object o) 方法 public boolean removeLastOccurrence(Object o) { if (o == null) { for (Node<E> x = last; x != null; x = x.prev) { if (x.item == null) { unlink(x); return true; } } } else { for (Node<E> x = last; x != null; x = x.prev) { if (o.equals(x.item)) { unlink(x); return true; } } } return false; } // 清空集合方法 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 set(int index, E element) { checkElementIndex(index); // 获取 node(int index) 找到指定该位置的节点 Node<E> x = node(index); // 获取该节点的元素，并替换 E oldVal = x.item; x.item = element; return oldVal; } // 获取指定位置的元素 public E get(int index) { checkElementIndex(index); return node(index).item; } // 获取集合的第一个元素 public E getFirst() { // 获取头节点 final Node<E> f = first; if (f == null) throw new NoSuchElementException(); return f.item; } // 获取集合的最后一个元素 public E getLast() { // 获取尾节点 final Node<E> l = last; if (l == null) throw new NoSuchElementException(); return l.item; } 

八、其他方法

// 返回传入的元素在集合中的位置，如果没有则返回 -1 public int indexOf(Object o) { int index = 0; if (o == null) { for (Node<E> x = first; x != null; x = x.next) { if (x.item == null) return index; index++; } } else { for (Node<E> x = first; x != null; x = x.next) { if (o.equals(x.item)) return index; index++; } } return -1; } // 判断集合中是否存在传入的元素 public boolean contains(Object o) { return indexOf(o) != -1; } 

九、遍历方法

(1) 迭代器方式

Iterator<Integer> iterator = list.iterator(); while (iterator.hasNext()) { iterator.next(); } 

(2) 使用 for 循环

for(int i=0; i<list.size(); i++) { list.get(i); } 

(3) 使用 foreach

for(String i: list) { } 

其中迭代器和 foreach 遍历的方式速度基本是一样的，因为 foreach 本质上也是用迭代器进行遍历。一定不要使用 for 循环对 LinkedList 进行遍历，速度会慢到令人绝望

具体原因可以去看：http://www.cnblogs.com/xrq730/p/5189565.html

十、参考

https://blog.csdn.net/u011240877/article/details/52876543
https://www.cnblogs.com/xrq730/p/5005347.html