LinkedList源碼剖析

時間 2019-11-16

標籤 linkedlist 源碼剖析欄目 Java 简体版

原文原文鏈接

LinkedList簡介

LinkedList是基於雙向循環鏈表（從源碼中能夠很容易看出）實現的，除了能夠當作鏈表來操做外，它還能夠當作棧、隊列和雙端隊列來使用。java

LinkedList一樣是非線程安全的，只在單線程下適合使用。數組

LinkedList實現了Serializable接口，所以它支持序列化，可以經過序列化傳輸，實現了Cloneable接口，能被克隆。安全

LinkedList源碼剖析

LinkedList的源碼以下（加入了比較詳細的註釋）：數據結構

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

總結

關於LinkedList的源碼，給出幾點比較重要的總結：函數

一、從源碼中很明顯能夠看出，LinkedList的實現是基於雙向循環鏈表的，且頭結點中不存放數據，以下圖;this

二、注意兩個不一樣的構造方法。無參構造方法直接創建一個僅包含head節點的空鏈表，包含Collection的構造方法，先調用無參構造方法創建一個空鏈表，然後將Collection中的數據加入到鏈表的尾部後面。spa

三、在查找和刪除某元素時，源碼中都劃分爲該元素爲null和不爲null兩種狀況來處理，LinkedList中容許元素爲null。.net

四、LinkedList是基於鏈表實現的，所以不存在容量不足的問題，因此這裏沒有擴容的方法。線程

五、注意源碼中的Entry<E> entry(int index)方法。該方法返回雙向鏈表中指定位置處的節點，而鏈表中是沒有下標索引的，要指定位置出的元素，就要遍歷該鏈表，從源碼的實現中，咱們看到這裏有一個加速動做。源碼中先將index與長度size的一半比較，若是index<size/2，就只從位置0日後遍歷到位置index處，而若是index>size/2，就只從位置size往前遍歷到位置index處。這樣能夠減小一部分沒必要要的遍歷，從而提升必定的效率（實際上效率仍是很低）。3d

六、注意鏈表類對應的數據結構Entry。以下;

 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 }