轉載請註明出處：http://blog.csdn.net/ns_code/article/details/35787253

您好，我正在參加CSDN博文大賽，如果您喜歡我的文章，希望您能幫我投一票，謝謝！

投票地址：http://vote.blog.csdn.net/Article/Details?articleid=35568011

LinkedList簡介

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

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

LinkedList實現了Serializable接口，因此它支持序列化，能夠通過序列化傳輸，實現了Cloneable接口，能被克隆。

LinkedList源碼剖析

LinkedList的源碼如下（加入了比較詳細的註釋）：

1. package java.util;
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);
10. // LinkedList中元素個數
11. private transient int size = 0;
13. // 默認構造函數：創建一個空的鏈表
14. public LinkedList() {
15. header.next = header.previous = header;
16. }
18. // 包含“集合”的構造函數:創建一個包含“集合”的LinkedList
19. public LinkedList(Collection<? extends E> c) {
20. this();
21. addAll(c);
22. }
24. // 獲取LinkedList的第一個元素
25. public E getFirst() {
26. if (size==0)
27. throw new NoSuchElementException();
29. // 鏈表的表頭header中不包含數據。
30. // 這裏返回header所指下一個節點所包含的數據。
31. return header.next.element;
32. }
34. // 獲取LinkedList的最後一個元素
35. public E getLast() {
36. if (size==0)
37. throw new NoSuchElementException();
39. // 由於LinkedList是雙向鏈表；而表頭header不包含數據。
40. // 因而，這裏返回表頭header的前一個節點所包含的數據。
41. return header.previous.element;
42. }
44. // 刪除LinkedList的第一個元素
45. public E removeFirst() {
46. return remove(header.next);
47. }
49. // 刪除LinkedList的最後一個元素
50. public E removeLast() {
51. return remove(header.previous);
52. }
54. // 將元素添加到LinkedList的起始位置
55. public void addFirst(E e) {
56. addBefore(e, header.next);
57. }
59. // 將元素添加到LinkedList的結束位置
60. public void addLast(E e) {
61. addBefore(e, header);
62. }
64. // 判斷LinkedList是否包含元素(o)
65. public boolean contains(Object o) {
66. return indexOf(o) != -1;
67. }
69. // 返回LinkedList的大小
70. public int size() {
71. return size;
72. }
74. // 將元素(E)添加到LinkedList中
75. public boolean add(E e) {
76. // 將節點(節點數據是e)添加到表頭(header)之前。
77. // 即，將節點添加到雙向鏈表的末端。
78. addBefore(e, header);
79. return true;
80. }
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. }
106. // 將“集合(c)”添加到LinkedList中。
107. // 實際上，是從雙向鏈表的末尾開始，將“集合(c)”添加到雙向鏈表中。
108. public boolean addAll(Collection<? extends E> c) {
109. return addAll(size, c);
110. }
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++;
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;
136. // 調整LinkedList的實際大小
137. size += numNew;
138. return true;
139. }
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. }
160. // 返回LinkedList指定位置的元素
161. public E get(int index) {
162. return entry(index).element;
163. }
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. }
173. // 在index前添加節點，且節點的值為element
174. public void add(int index, E element) {
175. addBefore(element, (index==size ? header : entry(index)));
176. }
178. // 刪除index位置的節點
179. public E remove(int index) {
180. return remove(entry(index));
181. }
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. }
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. }
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. }
242. // 返回第一個節點
243. // 若LinkedList的大小為0,則返回null
244. public E peek() {
245. if (size==0)
246. return null;
247. return getFirst();
248. }
250. // 返回第一個節點
251. // 若LinkedList的大小為0,則拋出異常
252. public E element() {
253. return getFirst();
254. }
256. // 刪除並返回第一個節點
257. // 若LinkedList的大小為0,則返回null
258. public E poll() {
259. if (size==0)
260. return null;
261. return removeFirst();
262. }
264. // 將e添加雙向鏈表末尾
265. public boolean offer(E e) {
266. return add(e);
267. }
269. // 將e添加雙向鏈表開頭
270. public boolean offerFirst(E e) {
271. addFirst(e);
272. return true;
273. }
275. // 將e添加雙向鏈表末尾
276. public boolean offerLast(E e) {
277. addLast(e);
278. return true;
279. }
281. // 返回第一個節點
282. // 若LinkedList的大小為0,則返回null
283. public E peekFirst() {
284. if (size==0)
285. return null;
286. return getFirst();
287. }
289. // 返回最後一個節點
290. // 若LinkedList的大小為0,則返回null
291. public E peekLast() {
292. if (size==0)
293. return null;
294. return getLast();
295. }
297. // 刪除並返回第一個節點
298. // 若LinkedList的大小為0,則返回null
299. public E pollFirst() {
300. if (size==0)
301. return null;
302. return removeFirst();
303. }
305. // 刪除並返回最後一個節點
306. // 若LinkedList的大小為0,則返回null
307. public E pollLast() {
308. if (size==0)
309. return null;
310. return removeLast();
311. }
313. // 將e插入到雙向鏈表開頭
314. public void push(E e) {
315. addFirst(e);
316. }
318. // 刪除並返回第一個節點
319. public E pop() {
320. return removeFirst();
321. }
323. // 從LinkedList開始向後查找，刪除第一個值為元素(o)的節點
324. // 從鏈表開始查找，如存在節點的值為元素(o)的節點，則刪除該節點
325. public boolean removeFirstOccurrence(Object o) {
326. return remove(o);
327. }
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. }
350. // 返回“index到末尾的全部節點”對應的ListIterator對象(List叠代器)
351. public ListIterator<E> listIterator(int index) {
352. return new ListItr(index);
353. }
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;
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. }
385. // 是否存在下一個元素
386. public boolean hasNext() {
387. // 通過元素索引是否等於“雙向鏈表大小”來判斷是否達到最後。
388. return nextIndex != size;
389. }
391. // 獲取下一個元素
392. public E next() {
393. checkForComodification();
394. if (nextIndex == size)
395. throw new NoSuchElementException();
397. lastReturned = next;
398. // next指向鏈表的下一個元素
399. next = next.next;
400. nextIndex++;
401. return lastReturned.element;
402. }
404. // 是否存在上一個元素
405. public boolean hasPrevious() {
406. // 通過元素索引是否等於0，來判斷是否達到開頭。
407. return nextIndex != 0;
408. }
410. // 獲取上一個元素
411. public E previous() {
412. if (nextIndex == 0)
413. throw new NoSuchElementException();
415. // next指向鏈表的上一個元素
416. lastReturned = next = next.previous;
417. nextIndex--;
418. checkForComodification();
419. return lastReturned.element;
420. }
422. // 獲取下一個元素的索引
423. public int nextIndex() {
424. return nextIndex;
425. }
427. // 獲取上一個元素的索引
428. public int previousIndex() {
429. return nextIndex-1;
430. }
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. }
450. // 設置當前節點為e
451. public void set(E e) {
452. if (lastReturned == header)
453. throw new IllegalStateException();
454. checkForComodification();
455. lastReturned.element = e;
456. }
458. // 將e添加到當前節點的前面
459. public void add(E e) {
460. checkForComodification();
461. lastReturned = header;
462. addBefore(e, next);
463. nextIndex++;
464. expectedModCount++;
465. }
467. // 判斷 “modCount和expectedModCount是否相等”，依次來實現fail-fast機制。
468. final void checkForComodification() {
469. if (modCount != expectedModCount)
470. throw new ConcurrentModificationException();
471. }
472. }
474. // 雙向鏈表的節點所對應的數據結構。
475. // 包含3部分：上一節點，下一節點，當前節點值。
476. private static class Entry<E> {
477. // 當前節點所包含的值
478. E element;
479. // 下一個節點
480. Entry<E> next;
481. // 上一個節點
482. Entry<E> previous;
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. }
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. }
511. // 將節點從鏈表中刪除
512. private E remove(Entry<E> e) {
513. if (e == header)
514. throw new NoSuchElementException();
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. }
526. // 反向叠代器
527. public Iterator<E> descendingIterator() {
528. return new DescendingIterator();
529. }
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. }
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. }
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;
575. if (a.length > size)
576. a[size] = null;
578. return a;
579. }
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. }
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;
598. // 將鏈表中所有節點的數據都添加到克隆對象中
599. for (Entry<E> e = header.next; e != header; e = e.next)
600. clone.add(e.element);
602. return clone;
603. }
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();
612. // 寫入“容量”
613. s.writeInt(size);
615. // 將鏈表中所有節點的數據都寫入到輸出流中
616. for (Entry e = header.next; e != header; e = e.next)
617. s.writeObject(e.element);
618. }
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();
627. // 從輸入流中讀取“容量”
628. int size = s.readInt();
630. // 新建鏈表表頭節點
631. header = new Entry<E>(null, null, null);
632. header.next = header.previous = header;
634. // 從輸入流中將“所有的元素值”並逐個添加到鏈表中
635. for (int i=0; i<size; i++)
636. addBefore((E)s.readObject(), header);
637. }
639. }

幾點總結

關於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。如下;

1. // 雙向鏈表的節點所對應的數據結構。
2. // 包含3部分：上一節點，下一節點，當前節點值。
3. private static class Entry<E> {
4. // 當前節點所包含的值
5. E element;
6. // 下一個節點
7. Entry<E> next;
8. // 上一個節點
9. Entry<E> previous;
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、要註意源碼中還實現了棧和隊列的操作方法，因此也可以作為棧、隊列和雙端隊列來使用。

轉：【Java集合源碼剖析】LinkedList源碼剖析