【Java集合源码剖析】LinkedList源码剖析

对比了一下jdk1.6和jdk1.8的源码，差别有点太大了，所以决定以大神的jdk1.6分析的为主，先把基础的学会，再弄新的

参考的文章来源：http://blog.csdn.net/ns_code/article/details/35787253

LinkedList简介

    LinkedList是基于双向循环链表（从源码中可以很容易看出）实现的，除了可以当做链表来操作外，它还可以当做栈、队列和双端队列来使用。

    LinkedList同样是非线程安全的，只在单线程下适合使用。

    LinkedList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了Cloneable接口，能被克隆。

LinkedList源码剖析

    LinkedList的源码如下（加入了比较详细的注释）：

[java]  view plain  copy

 

1. package java.util;    
2.    
3. public class LinkedList<E>    
4.     extends AbstractSequentialList<E>    
5.     implements List<E>, Deque<E>, Cloneable, java.io.Serializable    
6. {      
   
7.     // 链表的表头，表头不包含任何数据。Entry是个链表类数据结构。具体实现见最下面
8.     // 注意：表头是空的，不包含任何数据    
9.     private transient Entry<E> header = new Entry<E>(null, null, null);    
10.    
11.     // LinkedList中元素个数    
12.     private transient int size = 0;    
13.    
14.     // 默认构造函数：创建一个空的链表 ，把它的next和previous都指向表头   
15.     public LinkedList() {    
16.         header.next = header.previous = header;    
17.     }    
18.    
19.     // 包含“集合”的构造函数:创建一个包含“集合”的LinkedList    
20.     public LinkedList(Collection<? extends E> c) {    
21.         this();    
22.         addAll(c);    
23.     }    
24.    
25.     // 获取LinkedList的第一个元素    
26.     public E getFirst() {    
27.         if (size==0)    
28.             throw new NoSuchElementException();    
29.    
30.         // 链表的表头header中不包含数据。    
31.         // 这里返回header所指下一个节点所包含的数据。    
32.         return header.next.element;    
33.     }    
34.    
35.     // 获取LinkedList的最后一个节点的数据    
36.     public E getLast()  {    
37.         if (size==0)    
38.             throw new NoSuchElementException();    
39.    
40.         // 由于LinkedList是双向链表；而表头header不包含数据。    
41.         // 因而，这里返回表头header的前一个节点所包含的数据。    
42.         return header.previous.element;    
43.     }    
44.    
45.     // 删除LinkedList的第一个节点，所以不用header.next.element    
46.     public E removeFirst() {    
47.         return remove(header.next);    
48.     }    
49.    
50.     // 删除LinkedList的最后一个节点，所以不用header.previous.element    
51.     public E removeLast() {    
52.         return remove(header.previous);    
53.     }    
54.    
55.     // 将元素添加到LinkedList的起始位置    
56.     public void addFirst(E e) {    
57.         addBefore(e, header.next);    
58.     }    
59.    
60.     // 将元素添加到LinkedList的结束位置
61.     // 由于是双向链表，所以header的前节点就是LinkList的尾节点    
62.     public void addLast(E e) {    
63.         addBefore(e, header);    
64.     }    
65.    
66.     // 判断LinkedList是否包含元素(o) ，其实就是调用indexOf，如果有就返回索引，没有直接返回-1，   
67.     public boolean contains(Object o) {    
68.         return indexOf(o) != -1;    
69.     }    
70.    
71.     // 返回LinkedList的大小    
72.     public int size() {    
73.         return size;    
74.     }    
75.    
76.     // 将元素(E)添加到LinkedList中，做法上和addLast相同，然而返回值不同    
77.     public boolean add(E e) {    
78.         // 将节点(节点数据是e)添加到表头(header)之前。    
79.         // 即，将节点添加到双向链表的末端。    
80.         addBefore(e, header);    
81.         return true;    
82.     }    
83.    
84.     // 从LinkedList中删除元素(o)    
85.     // 从链表开始查找，如存在元素(o)则删除该元素并返回true；    
86.     // 否则，返回false。
87.     // 下面的remove方法里的remove方法调用的是自己的private remove方法
88.    // private E remove(Entry<E> e){
89.           if(e == header){
90.                throw new NoSuchElementException();
91.           }
92.           //保留一下要删除的节点
93.           E result = e.element;
94.           // 把要删的下一个节点与前一个节点连上，双向连上
95.           e.previous.next = e.next;
96.           e.next.previous = e.prevous;
97.           e.previous = e.next = null;
98.           e.elment = null;
99.           size--;   modeCount++;
100.           return result;
101.      }  
102.     public boolean remove(Object o) {   
103.         if (o==null) {    
104.             // 若o为null的删除情况
105.             // 结束的标志是又从表头开始，又回到了表头，双向的链表    
106.             for (Entry<E> e = header.next; e != header; e = e.next) {    
107.                 if (e.element==null) {    
108.                     remove(e);    
109.                     return true;    
110.                 }    
111.             }    
112.         } else {    
113.             // 若o不为null的删除情况    
114.             for (Entry<E> e = header.next; e != header; e = e.next) {    
115.                 if (o.equals(e.element)) {    
116.                     remove(e);    
117.                     return true;    
118.                 }    
119.             }    
120.         }    
121.         return false;    
122.     }
123.    
124.     // 将“集合(c)”添加到LinkedList中。    
125.     // 实际上，是从双向链表的末尾开始，将“集合(c)”添加到双向链表中。    
126.     public boolean addAll(Collection<? extends E> c) {    
127.         return addAll(size, c);    
128.     }    
129.    
130.     // 从双向链表的index开始，将“集合(c)”添加到双向链表中。    
131.     public boolean addAll(int index, Collection<? extends E> c) {    
132.         if (index < 0 || index > size)    
133.             throw new IndexOutOfBoundsException("Index: "+index+    
134.                                                 ", Size: "+size);    
135.         Object[] a = c.toArray();    
136.         // 获取集合的长度    
137.         int numNew = a.length;    
138.         if (numNew==0)    
139.             return false;    
140.         modCount++;    
141.    
142.         // 设置“当前要插入节点的后一个节点”，比如要插入的位置为index，successor相当于index+1位置
143.         //private Entry<E> entry(int index),返回当前index坐标的节点，具体实现就是先创建一个
144.         //header的引用，然后for（header.next()）直到循环到index为止，然后return e ，具体实现见下面  
145.         Entry<E> successor = (index==size ? header : entry(index));    
146.         // 设置“当前要插入节点的前一个节点”，predecessor相当于index-1的位置    
147.         Entry<E> predecessor = successor.previous;    
148.         // 将集合(c)全部插入双向链表中    
149.         for (int i=0; i<numNew; i++) {
150.         // 结合Entry的构造函数，这句相当于把a[i]插入successor和predecessor中间 
151.         // Entry(A,B,C)的效果    C<-A->B，A的下一个连上了B，A的上一个连上了C   
152.             Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
153.        //  插入节点后，将前一节点的next指向当前节点    C->A  使C的next连上了A，最后形成C <=>A->B
154.             predecessor.next = e;
155.        // 更新predecessor的指针，这样所有数据从尾部开始插，先插入的一点点向前移动，successor不动
156.             predecessor = e;    
157.         }    
           // 将index+1的节点与collection的最后节点相连 
158.         successor.previous = predecessor;    
159.    
160.         // 调整LinkedList的实际大小    
161.         size += numNew;    
162.         return true;    
163.     }    
164. 
     
165.     // 清空双向链表    
166.     public void clear() {    
167.         Entry<E> e = header.next;    
168.         // 从表头开始，逐个向后遍历；对遍历到的节点执行一下操作：    
169.         // (01) 设置前一个节点为null     
170.         // (02) 设置当前节点的内容为null     
171.         // (03) 设置后一个节点为“新的当前节点”    
172.         while (e != header) {    
173.             Entry<E> next = e.next;    
174.             e.next = e.previous = null;    
175.             e.element = null;    
176.             e = next;    
177.         }    
178.         header.next = header.previous = header;    
179.         // 设置大小为0    
180.         size = 0;    
181.         modCount++;    
182.     }    
183.   }
184.     // 返回LinkedList指定位置的元素    
185.     public E get(int index) {    
186.         return entry(index).element;    
187.     }    
188.    
189.     // 设置index位置对应的节点的值为element    
190.     public E set(int index, E element) {    
191.         Entry<E> e = entry(index);    
192.         E oldVal = e.element;    
193.         e.element = element;    
194.         return oldVal;    
195.     }    
196.      
197.     // 在index前添加节点，且节点的值为element    
198.     public void add(int index, E element) {    
199.         addBefore(element, (index==size ? header : entry(index)));    
200.     }    
201.    
202.     // 删除index位置的节点    
203.     public E remove(int index) {    
204.         return remove(entry(index));    
205.     }    
206.    
207.     // 获取双向链表中指定位置的节点    
208.     private Entry<E> entry(int index) {    
209.         if (index < 0 || index >= size)    
210.             throw new IndexOutOfBoundsException("Index: "+index+    
211.                                                 ", Size: "+size);    
212.         Entry<E> e = header;    
213.         // 获取index处的节点。    
214.         // 若index < 双向链表长度的1/2,则从前先后查找;    
215.         // 否则，从后向前查找。    
216.         if (index < (size >> 1)) {    
217.             for (int i = 0; i <= index; i++)    
218.                 e = e.next;    
219.         } else {    
220.             for (int i = size; i > index; i--)    
221.                 e = e.previous;    
222.         }    
223.         return e;    
224.     }    
225.    
226.     // 从前向后查找，返回“值为对象(o)的节点对应的索引”    
227.     // 不存在就返回-1    
228.     public int indexOf(Object o) {    
229.         int index = 0;    
230.         if (o==null) {    
231.             for (Entry e = header.next; e != header; e = e.next) {    
232.                 if (e.element==null)    
233.                     return index;    
234.                 index++;    
235.             }    
236.         } else {    
237.             for (Entry e = header.next; e != header; e = e.next) {    
238.                 if (o.equals(e.element))    
239.                     return index;    
240.                 index++;    
241.             }    
242.         }    
243.         return -1;    
244.     }    
245.    
246.     // 从后向前查找，返回“值为对象(o)的节点对应的索引”    
247.     // 不存在就返回-1    
248.     public int lastIndexOf(Object o) {    
249.         int index = size;    
250.         if (o==null) {    
251.             for (Entry e = header.previous; e != header; e = e.previous) {    
252.                 index--;    
253.                 if (e.element==null)    
254.                     return index;    
255.             }    
256.         } else {    
257.             for (Entry e = header.previous; e != header; e = e.previous) {    
258.                 index--;    
259.                 if (o.equals(e.element))    
260.                     return index;    
261.             }    
262.         }    
263.         return -1;    
264.     }    
265.    
266.     // 返回第一个节点    
267.     // 若LinkedList的大小为0,则返回null    
268.     public E peek() {    
269.         if (size==0)    
270.             return null;    
271.         return getFirst();    
272.     }    
273.    
274.     // 返回第一个节点    
275.     // 若LinkedList的大小为0,则抛出异常    
276.     public E element() {    
277.         return getFirst();    
278.     }    
279.    
280.     // 删除并返回第一个节点    
281.     // 若LinkedList的大小为0,则返回null    
282.     public E poll() {    
283.         if (size==0)    
284.             return null;    
285.         return removeFirst();    
286.     }    
287.    
288.     // 将e添加双向链表末尾    
289.     public boolean offer(E e) {    
290.         return add(e);    
291.     }    
292.    
293.     // 将e添加双向链表开头    
294.     public boolean offerFirst(E e) {    
295.         addFirst(e);    
296.         return true;    
297.     }    
298.    
299.     // 将e添加双向链表末尾    
300.     public boolean offerLast(E e) {    
301.         addLast(e);    
302.         return true;    
303.     }    
304.    
305.     // 返回第一个节点    
306.     // 若LinkedList的大小为0,则返回null    
307.     public E peekFirst() {    
308.         if (size==0)    
309.             return null;    
310.         return getFirst();    
311.     }    
312.    
313.     // 返回最后一个节点    
314.     // 若LinkedList的大小为0,则返回null    
315.     public E peekLast() {    
316.         if (size==0)    
317.             return null;    
318.         return getLast();    
319.     }    
320.    
321.     // 删除并返回第一个节点    
322.     // 若LinkedList的大小为0,则返回null    
323.     public E pollFirst() {    
324.         if (size==0)    
325.             return null;    
326.         return removeFirst();    
327.     }    
328.    
329.     // 删除并返回最后一个节点    
330.     // 若LinkedList的大小为0,则返回null    
331.     public E pollLast() {    
332.         if (size==0)    
333.             return null;    
334.         return removeLast();    
335.     }    
336.    
337.     // 将e插入到双向链表开头    
338.     public void push(E e) {    
339.         addFirst(e);    
340.     }    
341.    
342.     // 删除并返回第一个节点    
343.     public E pop() {    
344.         return removeFirst();    
345.     }    
346.    
347.     // 从LinkedList开始向后查找，删除第一个值为元素(o)的节点    
348.     // 从链表开始查找，如存在节点的值为元素(o)的节点，则删除该节点    
349.     public boolean removeFirstOccurrence(Object o) {    
350.         return remove(o);    
351.     }    
352.    
353.     // 从LinkedList末尾向前查找，删除第一个值为元素(o)的节点    
354.     // 从链表开始查找，如存在节点的值为元素(o)的节点，则删除该节点    
355.     public boolean removeLastOccurrence(Object o) {    
356.         if (o==null) {    
357.             for (Entry<E> e = header.previous; e != header; e = e.previous) {    
358.                 if (e.element==null) {    
359.                     remove(e);    
360.                     return true;    
361.                 }    
362.             }    
363.         } else {    
364.             for (Entry<E> e = header.previous; e != header; e = e.previous) {    
365.                 if (o.equals(e.element)) {    
366.                     remove(e);    
367.                     return true;    
368.                 }    
369.             }    
370.         }    
371.         return false;    
372.     }    
373.    
374.     // 返回“index到末尾的全部节点”对应的ListIterator对象(List迭代器)    
375.     public ListIterator<E> listIterator(int index) {    
376.         return new ListItr(index);    
377.     }    
378.    
379.     // List迭代器    
380.     private class ListItr implements ListIterator<E> {    
381.         // 上一次返回的节点    
382.         private Entry<E> lastReturned = header;    
383.         // 下一个节点    
384.         private Entry<E> next;    
385.         // 下一个节点对应的索引值    
386.         private int nextIndex;    
387.         // 期望的改变计数。用来实现fail-fast机制。    
388.         private int expectedModCount = modCount;    
389.    
390.         // 构造函数。    
391.         // 从index位置开始进行迭代    
392.         ListItr(int index) {    
393.             // index的有效性处理    
394.             if (index < 0 || index > size)    
395.                 throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+size);    
396.             // 若 “index 小于 ‘双向链表长度的一半’”，则从第一个元素开始往后查找；    
397.             // 否则，从最后一个元素往前查找。    
398.             if (index < (size >> 1)) {    
399.                 next = header.next;    
400.                 for (nextIndex=0; nextIndex<index; nextIndex++)    
401.                     next = next.next;    
402.             } else {    
403.                 next = header;    
404.                 for (nextIndex=size; nextIndex>index; nextIndex--)    
405.                     next = next.previous;    
406.             }    
407.         }    
408.    
409.         // 是否存在下一个元素    
410.         public boolean hasNext() {    
411.             // 通过元素索引是否等于“双向链表大小”来判断是否达到最后。    
412.             return nextIndex != size;    
413.         }    
414.    
415.         // 获取下一个元素    
416.         public E next() {    
417.             checkForComodification(); // 检查是否修改了  
418.             if (nextIndex == size)    
419.                 throw new NoSuchElementException();    
420.    
421.             lastReturned = next;    
422.             // next指向链表的下一个元素    
423.             next = next.next;    
424.             nextIndex++;    
425.             return lastReturned.element;    
426.         }    
427.    
428.         // 是否存在上一个元素    
429.         public boolean hasPrevious() {    
430.             // 通过元素索引是否等于0，来判断是否达到开头。    
431.             return nextIndex != 0;    
432.         }    
433.    
434.         // 获取上一个元素    
435.         public E previous() {    
436.             if (nextIndex == 0)    
437.             throw new NoSuchElementException();    
438.    
439.             // next指向链表的上一个元素    
440.             lastReturned = next = next.previous;    
441.             nextIndex--;    
442.             checkForComodification();    
443.             return lastReturned.element;    
444.         }    
445.    
446.         // 获取下一个元素的索引    
447.         public int nextIndex() {    
448.             return nextIndex;    
449.         }    
450.    
451.         // 获取上一个元素的索引    
452.         public int previousIndex() {    
453.             return nextIndex-1;    
454.         }    
455.    
456.         // 删除当前元素。    
457.         // 删除双向链表中的当前节点    
458.         public void remove() {    
459.             checkForComodification();    
460.             Entry<E> lastNext = lastReturned.next;    
461.             try {    
462.                 LinkedList.this.remove(lastReturned);    
463.             } catch (NoSuchElementException e) {    
464.                 throw new IllegalStateException();    
465.             }    
466.             if (next==lastReturned)    
467.                 next = lastNext;    
468.             else   
469.                 nextIndex--;    
470.             lastReturned = header;    
471.             expectedModCount++;    
472.         }    
473.    
474.         // 设置当前节点为e    
475.         public void set(E e) {    
476.             if (lastReturned == header)    
477.                 throw new IllegalStateException();    
478.             checkForComodification();    
479.             lastReturned.element = e;    
480.         }    
481.    
482.         // 将e添加到当前节点的前面    
483.         public void add(E e) {    
484.             checkForComodification();    
485.             lastReturned = header;    
486.             addBefore(e, next);    
487.             nextIndex++;    
488.             expectedModCount++;    
489.         }    
490.    
491.         // 判断 “modCount和expectedModCount是否相等”，依次来实现fail-fast机制。    
492.         final void checkForComodification() {    
493.             if (modCount != expectedModCount)    
494.             throw new ConcurrentModificationException();    
495.         }    
496.     }    
497.    
498.     // 双向链表的节点所对应的数据结构。    
499.     // 包含3部分：上一节点，下一节点，当前节点值。    
500.     private static class Entry<E> {    
501.         // 当前节点所包含的值    
502.         E element;    
503.         // 下一个节点    
504.         Entry<E> next;    
505.         // 上一个节点    
506.         Entry<E> previous;    
507.    
508.         /**   
509.          * 链表节点的构造函数。   
510.          * 参数说明：   
511.          *   element  —— 节点所包含的数据   
512.          *   next      —— 下一个节点   
513.          *   previous —— 上一个节点   
514.          */   
515.         Entry(E element, Entry<E> next, Entry<E> previous) {    
516.             this.element = element;    
517.             this.next = next;    
518.             this.previous = previous;    
519.         }    
520.     }    
521.    
522.     // 将节点(节点数据是e)添加到entry节点之前。    
523.     private Entry<E> addBefore(E e, Entry<E> entry) {    
524.         // 新建节点newEntry，将newEntry插入到节点e之前；并且设置newEntry的数据是e    
525.         Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);    
526.         newEntry.previous.next = newEntry;    
527.         newEntry.next.previous = newEntry;    
528.         // 修改LinkedList大小    
529.         size++;    
530.         // 修改LinkedList的修改统计数：用来实现fail-fast机制。    
531.         modCount++;    
532.         return newEntry;    
533.     }    
534.    
535.     // 将节点从链表中删除    
536.     private E remove(Entry<E> e) {    
537.         if (e == header)    
538.             throw new NoSuchElementException();    
539.    
540.         E result = e.element;    
541.         e.previous.next = e.next;    
542.         e.next.previous = e.previous;    
543.         e.next = e.previous = null;    
544.         e.element = null;    
545.         size--;    
546.         modCount++;    
547.         return result;    
548.     }    
549.    
550.     // 反向迭代器    
551.     public Iterator<E> descendingIterator() {    
552.         return new DescendingIterator();    
553.     }    
554.    
555.     // 反向迭代器实现类。    
556.     private class DescendingIterator implements Iterator {    
557.         final ListItr itr = new ListItr(size());    
558.         // 反向迭代器是否下一个元素。    
559.         // 实际上是判断双向链表的当前节点是否达到开头    
560.         public boolean hasNext() {    
561.             return itr.hasPrevious();    
562.         }    
563.         // 反向迭代器获取下一个元素。    
564.         // 实际上是获取双向链表的前一个节点    
565.         public E next() {    
566.             return itr.previous();    
567.         }    
568.         // 删除当前节点    
569.         public void remove() {    
570.             itr.remove();    
571.         }    
572.     }    
573.    
574.    
575.     // 返回LinkedList的Object[]数组    
576.     public Object[] toArray() {    
577.     // 新建Object[]数组    
578.     Object[] result = new Object[size];    
579.         int i = 0;    
580.         // 将链表中所有节点的数据都添加到Object[]数组中    
581.         for (Entry<E> e = header.next; e != header; e = e.next)    
582.             result[i++] = e.element;    
583.     return result;    
584.     }    
585.    
586.     // 返回LinkedList的模板数组。所谓模板数组，即可以将T设为任意的数据类型    
587.     public <T> T[] toArray(T[] a) {    
588.         // 若数组a的大小 < LinkedList的元素个数(意味着数组a不能容纳LinkedList中全部元素)    
589.         // 则新建一个T[]数组，T[]的大小为LinkedList大小，并将该T[]赋值给a。    
590.         if (a.length < size)    
591.             a = (T[])java.lang.reflect.Array.newInstance(    
592.                                 a.getClass().getComponentType(), size);    
593.         // 将链表中所有节点的数据都添加到数组a中    
594.         int i = 0;    
595.         Object[] result = a;    
596.         for (Entry<E> e = header.next; e != header; e = e.next)    
597.             result[i++] = e.element;    
598.    
599.         if (a.length > size)    
600.             a[size] = null;    
601.    
602.         return a;    
603.     }    
604.    
605.    
606.     // 克隆函数。返回LinkedList的克隆对象。    
607.     public Object clone() {    
608.         LinkedList<E> clone = null;    
609.         // 克隆一个LinkedList克隆对象    
610.         try {    
611.             clone = (LinkedList<E>) super.clone();    
612.         } catch (CloneNotSupportedException e) {    
613.             throw new InternalError();    
614.         }    
615.    
616.         // 新建LinkedList表头节点    
617.         clone.header = new Entry<E>(null, null, null);    
618.         clone.header.next = clone.header.previous = clone.header;    
619.         clone.size = 0;    
620.         clone.modCount = 0;    
621.    
622.         // 将链表中所有节点的数据都添加到克隆对象中    
623.         for (Entry<E> e = header.next; e != header; e = e.next)    
624.             clone.add(e.element);    
625.    
626.         return clone;    
627.     }    
628.    
629.     // java.io.Serializable的写入函数    
630.     // 将LinkedList的“容量，所有的元素值”都写入到输出流中    
631.     private void writeObject(java.io.ObjectOutputStream s)    
632.         throws java.io.IOException {    
633.         // Write out any hidden serialization magic    
634.         s.defaultWriteObject();    
635.    
636.         // 写入“容量”    
637.         s.writeInt(size);    
638.    
639.         // 将链表中所有节点的数据都写入到输出流中    
640.         for (Entry e = header.next; e != header; e = e.next)    
641.             s.writeObject(e.element);    
642.     }    
643.    
644.     // java.io.Serializable的读取函数：根据写入方式反向读出    
645.     // 先将LinkedList的“容量”读出，然后将“所有的元素值”读出    
646.     private void readObject(java.io.ObjectInputStream s)    
647.         throws java.io.IOException, ClassNotFoundException {    
648.         // Read in any hidden serialization magic    
649.         s.defaultReadObject();    
650.    
651.         // 从输入流中读取“容量”    
652.         int size = s.readInt();    
653.    
654.         // 新建链表表头节点    
655.         header = new Entry<E>(null, null, null);    
656.         header.next = header.previous = header;    
657.    
658.         // 从输入流中将“所有的元素值”并逐个添加到链表中    
659.         for (int i=0; i<size; i++)    
660.             addBefore((E)s.readObject(), header);    
661.     }    
662.    
663. } 
     
     

几点总结

    关于LinkedList的源码，给出几点比较重要的总结：

    1、从源码中很明显可以看出，LinkedList的实现是基于双向循环链表的，且头结点中不存放数据，如下图;

    2、注意两个不同的构造方法。无参构造方法直接建立一个仅包含head节点的空链表，包含Collection的构造方法，先调用无参构造方法建立一个空链表，而后将Collection中的数据加入到链表的尾部后面。

    3、在查找和删除某元素时，源码中都划分为该元素为null和不为null两种情况来处理，LinkedList中允许元素为null。

    4、LinkedList是基于链表实现的，因此不存在容量不足的问题，所以这里没有扩容的方法。

    5、注意源码中的Entry<E> entry(int index)方法。该方法返回双向链表中指定位置处的节点，而链表中是没有下标索引的，要指定位置出的元素，就要遍历该链表，从源码的实现中，我们看到这里有一个加速动作。源码中先将index与长度size的一半比较，如果index<size/2，就只从位置0往后遍历到位置index处，而如果index>size/2，就只从位置size往前遍历到位置index处。这样可以减少一部分不必要的遍历，从而提高一定的效率（实际上效率还是很低）。

    6、注意链表类对应的数据结构Entry。如下;

[java]  view plain  copy

 

1. // 双向链表的节点所对应的数据结构。    
2. // 包含3部分：上一节点，下一节点，当前节点值。    
3. private static class Entry<E> {    
4.     // 当前节点所包含的值    
5.     E element;    
6.     // 下一个节点    
7.     Entry<E> next;    
8.     // 上一个节点    
9.     Entry<E> previous;    
10.   
11.     /**   
12.      * 链表节点的构造函数。   
13.      * 参数说明：   
14.      *   element  —— 节点所包含的数据   
15.      *   next      —— 下一个节点   
16.      *   previous —— 上一个节点   
17.      */   
18.     Entry(E element, Entry<E> next, Entry<E> previous) {    
19.         this.element = element;    
20.         this.next = next;    
21.         this.previous = previous;    
22.     }    
23. }    

    7、LinkedList是基于链表实现的，因此插入删除效率高，查找效率低（虽然有一个加速动作）。
    8、要注意源码中还实现了栈和队列的操作方法，因此也可以作为栈、队列和双端队列来使用。