深入Java集合学习系列：LinkedList的实现原理

深入Java集合学习系列：LinkedList的实现原理
http://blog.csdn.net/zheng0518/article/details/42198599

1. LinkedList概述：

List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。

此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。

所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头或结尾遍历列表（从靠近指定索引的一端）。

注意，此实现不是同步的。如果多个线程同时访问一个链接列表，而其中至少一个线程从结构上修改了该列表，则它必须保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法来“包装”该列表。最好在创建时完成这一操作，以防止对列表进行意外的不同步访问，如下所示：
```
                    List list = Collections.synchronizedList(new LinkedList(...));
```
此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：在迭代器创建之后，如果从结构上对列表进行修改，除非通过迭代器自身的 remove 或 add 方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不冒将来不确定的时间任意发生不确定行为的风险。

注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何硬性保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。

2. LinkedList的实现：
Java代码
1. private transient Entry<E> header = new Entry<E>(null, null, null);
这个成员变量是LinkedList的关键，它在链表中没有实际数据意义，是链表的标示（通俗一点就是链表的第一个无意义的元素），而且被修饰为transient，标示着他不会被序列化。header也可以当做队列末尾的元素，因为是双向列表，所以header.next末尾元素后边的元素就成了队首元素，header.previous就是队尾元素了，看一下它的添加方法
Java代码
1. public void addFirst(E paramE) {
2. addBefore(paramE, this.header.next);//队首
3. }
4. public void addLast(E paramE) {
5. addBefore(paramE, this.header);//队尾
6. }
以上两个方法都利用addBefore方法将元素添加到指定对象之前，

addFirst向队头加元素，将元素paramE添加到header.next-队首元素之前；

addLast向队尾加元素，将元素paramE添加到header之前；

再看一下addBefore(E e,Entry<E> entry)函数
Java代码
1. /***
2. * 要添加的元素：paramE
3. * 目标对象：paramEntry
4. */
5. private Entry<E> addBefore(E paramE, Entry<E> paramEntry)
6. {
7. //要添加的对象
8. Entry localEntry = new Entry(paramE, paramEntry, paramEntry.previous);
9. /***
10. * localEntry.previous = paramEntry.previous
11. * 目标对象的前一元素的后一元素（localEntry.previous.next）设置为要添加的对象
12. */
13. localEntry.previous.next = localEntry;
14. /***
15. * localEntry.next = paramEntry
16. * 目标对象的前一元素（localEntry.next.previous）设置为要添加的对象
17. */
18. localEntry.next.previous = localEntry;
19. this.size += 1;
20. this.modCount += 1;
21. return localEntry;
22. }
链表的基本特性是插入速度快，遍历速度慢，下面两个方法可以反映这个特点
Java代码
1. public int indexOf(Object paramObject) {
2. int i = 0;
3. Entry localEntry;
4. /***
5. * 遍历规则：从头到尾，序列呈升序状态
6. */
7. if (paramObject == null)
8. for (localEntry = this.header.next; localEntry != this.header; localEntry = localEntry.next) {
9. if (localEntry.element == null)
10. return i;
11. i++;
12. }
13. else {
14. for (localEntry = this.header.next; localEntry != this.header; localEntry = localEntry.next) {
15. if (paramObject.equals(localEntry.element))
16. return i;
17. i++;
18. }
19. }
20. return -1;
21. }
22. public int lastIndexOf(Object paramObject) {
23. int i = this.size;
24. Entry localEntry;
25. /***
26. * 遍历规则：从尾到头，序列呈降序状态
27. */
28. if (paramObject == null) {
29. for (localEntry = this.header.previous; localEntry != this.header; localEntry = localEntry.previous) {
30. i--;
31. if (localEntry.element == null)
32. return i;
33. }
34. }else {
35. for (localEntry = this.header.previous; localEntry != this.header; localEntry = localEntry.previous) {
36. i--;
37. if (paramObject.equals(localEntry.element))
38. return i;
39. }
40. }
41. return -1;
42. }
值得注意的是，链表插入数据速度快的说法是相对的，在数据量很小的时候，ArrayList的插入速度不仅不比LinkedList慢，而且还快很多（本文不作介绍，读者可自行测试），只有当数据量达到一定量，这个特性才会体现出来，这需要开发者明确需求场景

LinkedList的方法entry(int index)类似ArrayList的get(int index)
Java代码
1. /***
2. * 根据序号获取Entry对象
3. */
4. private Entry<E> entry(int paramInt) {
5. if ((paramInt < 0) || (paramInt >= this.size)) {
6. throw new IndexOutOfBoundsException("Index: " + paramInt + ", Size: " + this.size);
7. }
8. Entry localEntry = this.header;
9. int i;
10. /***
11. * 二分法：目标序号小于Size的1/2，则从头到尾
12. * 如果大于Size的1/2，则从尾到头
13. */
14. if (paramInt < this.size >> 1) {
15. for (i = 0; i <= paramInt; i++)
16. localEntry = localEntry.next;
17. } else {
18. for (i = this.size; i > paramInt; i--)
19. localEntry = localEntry.previous;
20. }
21. return localEntry;
22. }
LinkedList还提供了降序迭代器，如下
Java代码
1. public Iterator<E> descendingIterator() {
2. return new DescendingIterator(null);
3. }
关于降序迭代的具体实现可以看看源码，很简单

LinkedList是针对链表操作的一个比较全的实现，对于频繁的数据插入有较高效率，研究其具体实现可更有利于准确的使用它。该类的toArray、clone以及其他一些方法很值得参考。

3. LinkedList.Entry

LinkedList的内部类Entry是实现Deque接口的基本操作单元，其结构如下：
Java代码
1. private static class Entry<E>
2. {
3. E element;
4. Entry<E> next;
5. Entry<E> previous;
6. /***
7. * 构造方法：目标对象paramE将被放置在paramEntry1之前，paramEntry2之后
8. */
9. Entry(E paramE, Entry<E> paramEntry1, Entry<E> paramEntry2)
10. {
11. this.element = paramE;
12. this.next = paramEntry1;
13. this.previous = paramEntry2;
14. }
15. }
4. 内部迭代器：ListItr

虽然上层父类AbstractList<E>已经实现了迭代器，但LinkedList的直接父类AbstractSequentialList<E>给子类重新定义个一个需要实现的迭代器的抽象方法，代码如下：
Java代码
1. public abstract class AbstractSequentialList<E> extends AbstractList<E> {
2. /***
3. * 返回子类实现的迭代器
4. */
5. public Iterator<E> iterator() {
6. return listIterator();
7. }
8. public abstract ListIterator<E> listIterator(int paramInt);
9. }
此处实现的迭代器内部机制跟AbstractList基本一致，可以看看源码

此类的迭代器的实现机制可以通过ListItr的remove方法来分析，同时也可分析Java对双端队列的处理办法
Java代码
1. /***
2. * 当前指针位置：this.next
3. * 当前所操作的对象：this.lastReturned
4. */
5. public void remove() {
6. checkForComodification();
7. LinkedList.Entry localEntry = this.lastReturned.next;
8. try {
9. LinkedList.this.remove(this.lastReturned);
10. } catch (NoSuchElementException localNoSuchElementException) {
11. throw new IllegalStateException();
12. }
13. /***
14. * 当链表的size为0，指针会指向this.header，其他方法（如set方法）将以此判断当前操作对象的状态
15. */
16. if (this.next == this.lastReturned)
17. this.next = localEntry;
18. else
19. this.nextIndex -= 1;
20. /***
21. * 调用LinkedList.this.remove(E)之后
22. * 当前操作对象this.lastReturned指向的对象被设置为this.header（原对象为null）
23. * 指针移动到this.lastReturned.next
24. */
25. this.lastReturned = LinkedList.this.header;
26. //修改次数加1
27. this.expectedModCount += 1;
28. }
以上便是笔者对LinkedList的认识，有不足之处请各位看官多多提点，共同学习，共同进步。
相关阅读:
被劣质代码“残害”的这些年
 17 个案例带你 5 分钟搞定 Linux 正则表达式
 nginx配置详解
 探究 Go 语言 defer 语句的三种机制
 git 生成ssh
关于Laravel 与 Nginx 限流策略防止恶意请求
 保持开源项目健康运行并减少压力的 10 件事
 带着canvas去流浪系列之三绘制饼图
 无码系列-6 数据缓存设计经验谈
 IoT开发精英实战营招募啦！速来报名！
原文地址：https://www.cnblogs.com/leeeee/p/7276063.html

深入Java集合学习系列：LinkedList的实现原理

1. LinkedList概述：

2. LinkedList的实现：

3. LinkedList.Entry

4. 内部迭代器：ListItr