Java 集合系列05之 LinkedList詳細介紹(源碼解析)和使用示例
概要
前面，咱們已經學習了ArrayList，並瞭解了fail-fast機制。這一章咱們接着學習List的實現類——LinkedList。
和學習ArrayList同樣，接下來呢，咱們先對LinkedList有個總體認識，而後再學習它的源碼；最後再經過實例來學會使用LinkedList。內容包括：
第1部分 LinkedList介紹
第2部分 LinkedList數據結構
第3部分 LinkedList源碼解析(基於JDK1.6.0_45)
第4部分 LinkedList遍歷方式
第5部分 LinkedList示例
html
轉載請註明出處：http://www.cnblogs.com/skywang12345/p/3308807.htmljava
第1部分 LinkedList介紹
LinkedList簡介數組
LinkedList 是一個繼承於AbstractSequentialList的雙向鏈表。它也能夠被看成堆棧、隊列或雙端隊列進行操做。
LinkedList 實現 List 接口，能對它進行隊列操做。
LinkedList 實現 Deque 接口，即能將LinkedList看成雙端隊列使用。
LinkedList 實現了Cloneable接口，即覆蓋了函數clone()，能克隆。
LinkedList 實現java.io.Serializable接口，這意味着LinkedList支持序列化，能經過序列化去傳輸。
LinkedList 是非同步的。數據結構
LinkedList構造函數框架
// 默認構造函數 LinkedList() // 建立一個LinkedList，保護Collection中的所有元素。 LinkedList(Collection<? extends E> collection)
LinkedList的API ide
LinkedList的API boolean add(E object) void add(int location, E object) boolean addAll(Collection<? extends E> collection) boolean addAll(int location, Collection<? extends E> collection) void addFirst(E object) void addLast(E object) void clear() Object clone() boolean contains(Object object) Iterator<E> descendingIterator() E element() E get(int location) E getFirst() E getLast() int indexOf(Object object) int lastIndexOf(Object object) ListIterator<E> listIterator(int location) boolean offer(E o) boolean offerFirst(E e) boolean offerLast(E e) E peek() E peekFirst() E peekLast() E poll() E pollFirst() E pollLast() E pop() void push(E e) E remove() E remove(int location) boolean remove(Object object) E removeFirst() boolean removeFirstOccurrence(Object o) E removeLast() boolean removeLastOccurrence(Object o) E set(int location, E object) int size() <T> T[] toArray(T[] contents) Object[] toArray()
AbstractSequentialList簡介函數
在介紹LinkedList的源碼以前，先介紹一下AbstractSequentialList。畢竟，LinkedList是AbstractSequentialList的子類。性能
AbstractSequentialList 實現了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)這些函數。這些接口都是隨機訪問List的，LinkedList是雙向鏈表；既然它繼承於AbstractSequentialList，就至關於已經實現了「get(int index)這些接口」。學習
此外，咱們若須要經過AbstractSequentialList本身實現一個列表，只須要擴展此類，並提供 listIterator() 和 size() 方法的實現便可。若要實現不可修改的列表，則須要實現列表迭代器的 hasNext、next、hasPrevious、previous 和 index 方法便可。測試
第2部分 LinkedList數據結構
LinkedList的繼承關係
java.lang.Object ↳ java.util.AbstractCollection<E> ↳ java.util.AbstractList<E> ↳ java.util.AbstractSequentialList<E> ↳ java.util.LinkedList<E> public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable {}
LinkedList與Collection關係以下圖：
LinkedList的本質是雙向鏈表。
(01) LinkedList繼承於AbstractSequentialList，而且實現了Dequeue接口。
(02) LinkedList包含兩個重要的成員：header 和 size。
header是雙向鏈表的表頭，它是雙向鏈表節點所對應的類Entry的實例。Entry中包含成員變量： previous, next, element。其中，previous是該節點的上一個節點，next是該節點的下一個節點，element是該節點所包含的值。
size是雙向鏈表中節點的個數。
第3部分 LinkedList源碼解析(基於JDK1.6.0_45)
爲了更瞭解LinkedList的原理，下面對LinkedList源碼代碼做出分析。
在閱讀源碼以前，咱們先對LinkedList的總體實現進行大體說明：
LinkedList其實是經過雙向鏈表去實現的。既然是雙向鏈表，那麼它的順序訪問會很是高效，而隨機訪問效率比較低。
既然LinkedList是經過雙向鏈表的，可是它也實現了List接口{也就是說，它實現了get(int location)、remove(int location)等「根據索引值來獲取、刪除節點的函數」}。LinkedList是如何實現List的這些接口的，如何將「雙向鏈表和索引值聯繫起來的」？
實際原理很是簡單，它就是經過一個計數索引值來實現的。例如，當咱們調用get(int location)時，首先會比較「location」和「雙向鏈表長度的1/2」；若前者大，則從鏈表頭開始日後查找，直到location位置；不然，從鏈表末尾開始先前查找，直到location位置。
這就是「雙線鏈表和索引值聯繫起來」的方法。
好了，接下來開始閱讀源碼(只要理解雙向鏈表，那麼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 }
總結：
(01) LinkedList 其實是經過雙向鏈表去實現的。
它包含一個很是重要的內部類：Entry。Entry是雙向鏈表節點所對應的數據結構，它包括的屬性有：當前節點所包含的值，上一個節點，下一個節點。
(02) 從LinkedList的實現方式中能夠發現，它不存在LinkedList容量不足的問題。
(03) LinkedList的克隆函數，便是將所有元素克隆到一個新的LinkedList對象中。
(04) LinkedList實現java.io.Serializable。當寫入到輸出流時，先寫入「容量」，再依次寫入「每個節點保護的值」；當讀出輸入流時，先讀取「容量」，再依次讀取「每個元素」。
(05) 因爲LinkedList實現了Deque，而Deque接口定義了在雙端隊列兩端訪問元素的方法。提供插入、移除和檢查元素的方法。每種方法都存在兩種形式：一種形式在操做失敗時拋出異常，另外一種形式返回一個特殊值（null 或 false，具體取決於操做）。
總結起來以下表格：
第一個元素（頭部） 最後一個元素（尾部）
拋出異常 特殊值 拋出異常 特殊值
插入 addFirst(e) offerFirst(e) addLast(e) offerLast(e)
移除 removeFirst() pollFirst() removeLast() pollLast()
檢查 getFirst() peekFirst() getLast() peekLast()
(06) LinkedList能夠做爲FIFO(先進先出)的隊列，做爲FIFO的隊列時，下表的方法等價：
隊列方法 等效方法
add(e) addLast(e)
offer(e) offerLast(e)
remove() removeFirst()
poll() pollFirst()
element() getFirst()
peek() peekFirst()
(07) LinkedList能夠做爲LIFO(後進先出)的棧，做爲LIFO的棧時，下表的方法等價：
棧方法 等效方法
push(e) addFirst(e)
pop() removeFirst()
peek() peekFirst()
第4部分 LinkedList遍歷方式
LinkedList遍歷方式
LinkedList支持多種遍歷方式。建議不要採用隨機訪問的方式去遍歷LinkedList，而採用逐個遍歷的方式。
(01) 第一種，經過迭代器遍歷。即經過Iterator去遍歷。
for(Iterator iter = list.iterator(); iter.hasNext();) iter.next();
(02) 經過快速隨機訪問遍歷LinkedList
int size = list.size(); for (int i=0; i<size; i++) { list.get(i); }
(03) 經過另一種for循環來遍歷LinkedList
for (Integer integ:list) ;
(04) 經過pollFirst()來遍歷LinkedList
while(list.pollFirst() != null) ;
(05) 經過pollLast()來遍歷LinkedList
while(list.pollLast() != null) ;
(06) 經過removeFirst()來遍歷LinkedList
try { while(list.removeFirst() != null) ; } catch (NoSuchElementException e) { }
(07) 經過removeLast()來遍歷LinkedList
try { while(list.removeLast() != null) ; } catch (NoSuchElementException e) { }
測試這些遍歷方式效率的代碼以下：
1 import java.util.List; 2 import java.util.Iterator; 3 import java.util.LinkedList; 4 import java.util.NoSuchElementException; 5 6 /* 7 * @desc 測試LinkedList的幾種遍歷方式和效率 8 * 9 * @author skywang 10 */ 11 public class LinkedListThruTest { 12 public static void main(String[] args) { 13 // 經過Iterator遍歷LinkedList 14 iteratorLinkedListThruIterator(getLinkedList()) ; 15 16 // 經過快速隨機訪問遍歷LinkedList 17 iteratorLinkedListThruForeach(getLinkedList()) ; 18 19 // 經過for循環的變種來訪問遍歷LinkedList 20 iteratorThroughFor2(getLinkedList()) ; 21 22 // 經過PollFirst()遍歷LinkedList 23 iteratorThroughPollFirst(getLinkedList()) ; 24 25 // 經過PollLast()遍歷LinkedList 26 iteratorThroughPollLast(getLinkedList()) ; 27 28 // 經過removeFirst()遍歷LinkedList 29 iteratorThroughRemoveFirst(getLinkedList()) ; 30 31 // 經過removeLast()遍歷LinkedList 32 iteratorThroughRemoveLast(getLinkedList()) ; 33 } 34 35 private static LinkedList getLinkedList() { 36 LinkedList llist = new LinkedList(); 37 for (int i=0; i<100000; i++) 38 llist.addLast(i); 39 40 return llist; 41 } 42 /** 43 * 經過快迭代器遍歷LinkedList 44 */ 45 private static void iteratorLinkedListThruIterator(LinkedList<Integer> list) { 46 if (list == null) 47 return ; 48 49 // 記錄開始時間 50 long start = System.currentTimeMillis(); 51 52 for(Iterator iter = list.iterator(); iter.hasNext();) 53 iter.next(); 54 55 // 記錄結束時間 56 long end = System.currentTimeMillis(); 57 long interval = end - start; 58 System.out.println("iteratorLinkedListThruIterator：" + interval+" ms"); 59 } 60 61 /** 62 * 經過快速隨機訪問遍歷LinkedList 63 */ 64 private static void iteratorLinkedListThruForeach(LinkedList<Integer> list) { 65 if (list == null) 66 return ; 67 68 // 記錄開始時間 69 long start = System.currentTimeMillis(); 70 71 int size = list.size(); 72 for (int i=0; i<size; i++) { 73 list.get(i); 74 } 75 // 記錄結束時間 76 long end = System.currentTimeMillis(); 77 long interval = end - start; 78 System.out.println("iteratorLinkedListThruForeach：" + interval+" ms"); 79 } 80 81 /** 82 * 經過另一種for循環來遍歷LinkedList 83 */ 84 private static void iteratorThroughFor2(LinkedList<Integer> list) { 85 if (list == null) 86 return ; 87 88 // 記錄開始時間 89 long start = System.currentTimeMillis(); 90 91 for (Integer integ:list) 92 ; 93 94 // 記錄結束時間 95 long end = System.currentTimeMillis(); 96 long interval = end - start; 97 System.out.println("iteratorThroughFor2：" + interval+" ms"); 98 } 99 100 /** 101 * 經過pollFirst()來遍歷LinkedList 102 */ 103 private static void iteratorThroughPollFirst(LinkedList<Integer> list) { 104 if (list == null) 105 return ; 106 107 // 記錄開始時間 108 long start = System.currentTimeMillis(); 109 while(list.pollFirst() != null) 110 ; 111 112 // 記錄結束時間 113 long end = System.currentTimeMillis(); 114 long interval = end - start; 115 System.out.println("iteratorThroughPollFirst：" + interval+" ms"); 116 } 117 118 /** 119 * 經過pollLast()來遍歷LinkedList 120 */ 121 private static void iteratorThroughPollLast(LinkedList<Integer> list) { 122 if (list == null) 123 return ; 124 125 // 記錄開始時間 126 long start = System.currentTimeMillis(); 127 while(list.pollLast() != null) 128 ; 129 130 // 記錄結束時間 131 long end = System.currentTimeMillis(); 132 long interval = end - start; 133 System.out.println("iteratorThroughPollLast：" + interval+" ms"); 134 } 135 136 /** 137 * 經過removeFirst()來遍歷LinkedList 138 */ 139 private static void iteratorThroughRemoveFirst(LinkedList<Integer> list) { 140 if (list == null) 141 return ; 142 143 // 記錄開始時間 144 long start = System.currentTimeMillis(); 145 try { 146 while(list.removeFirst() != null) 147 ; 148 } catch (NoSuchElementException e) { 149 } 150 151 // 記錄結束時間 152 long end = System.currentTimeMillis(); 153 long interval = end - start; 154 System.out.println("iteratorThroughRemoveFirst：" + interval+" ms"); 155 } 156 157 /** 158 * 經過removeLast()來遍歷LinkedList 159 */ 160 private static void iteratorThroughRemoveLast(LinkedList<Integer> list) { 161 if (list == null) 162 return ; 163 164 // 記錄開始時間 165 long start = System.currentTimeMillis(); 166 try { 167 while(list.removeLast() != null) 168 ; 169 } catch (NoSuchElementException e) { 170 } 171 172 // 記錄結束時間 173 long end = System.currentTimeMillis(); 174 long interval = end - start; 175 System.out.println("iteratorThroughRemoveLast：" + interval+" ms"); 176 } 177 178 }
執行結果：
iteratorLinkedListThruIterator：8 ms
iteratorLinkedListThruForeach：3724 ms
iteratorThroughFor2：5 ms
iteratorThroughPollFirst：8 ms
iteratorThroughPollLast：6 ms
iteratorThroughRemoveFirst：2 ms
iteratorThroughRemoveLast：2 ms
因而可知，遍歷LinkedList時，使用removeFist()或removeLast()效率最高。但用它們遍歷時，會刪除原始數據；若單純只讀取，而不刪除，應該使用第3種遍歷方式。
不管如何，千萬不要經過隨機訪問去遍歷LinkedList！
第5部分 LinkedList示例
下面經過一個示例來學習如何使用LinkedList的經常使用API
1 import java.util.List; 2 import java.util.Iterator; 3 import java.util.LinkedList; 4 import java.util.NoSuchElementException; 5 6 /* 7 * @desc LinkedList測試程序。 8 * 9 * @author skywang 10 * @email kuiwu-wang@163.com 11 */ 12 public class LinkedListTest { 13 public static void main(String[] args) { 14 // 測試LinkedList的API 15 testLinkedListAPIs() ; 16 17 // 將LinkedList看成 LIFO(後進先出)的堆棧 18 useLinkedListAsLIFO(); 19 20 // 將LinkedList看成 FIFO(先進先出)的隊列 21 useLinkedListAsFIFO(); 22 } 23 24 /* 25 * 測試LinkedList中部分API 26 */ 27 private static void testLinkedListAPIs() { 28 String val = null; 29 //LinkedList llist; 30 //llist.offer("10"); 31 // 新建一個LinkedList 32 LinkedList llist = new LinkedList(); 33 //---- 添加操做 ---- 34 // 依次添加1,2,3 35 llist.add("1"); 36 llist.add("2"); 37 llist.add("3"); 38 39 // 將「4」添加到第一個位置 40 llist.add(1, "4"); 41 42 43 System.out.println("\nTest \"addFirst(), removeFirst(), getFirst()\""); 44 // (01) 將「10」添加到第一個位置。 失敗的話，拋出異常！ 45 llist.addFirst("10"); 46 System.out.println("llist:"+llist); 47 // (02) 將第一個元素刪除。 失敗的話，拋出異常！ 48 System.out.println("llist.removeFirst():"+llist.removeFirst()); 49 System.out.println("llist:"+llist); 50 // (03) 獲取第一個元素。 失敗的話，拋出異常！ 51 System.out.println("llist.getFirst():"+llist.getFirst()); 52 53 54 System.out.println("\nTest \"offerFirst(), pollFirst(), peekFirst()\""); 55 // (01) 將「10」添加到第一個位置。 返回true。 56 llist.offerFirst("10"); 57 System.out.println("llist:"+llist); 58 // (02) 將第一個元素刪除。 失敗的話，返回null。 59 System.out.println("llist.pollFirst():"+llist.pollFirst()); 60 System.out.println("llist:"+llist); 61 // (03) 獲取第一個元素。 失敗的話，返回null。 62 System.out.println("llist.peekFirst():"+llist.peekFirst()); 63 64 65 System.out.println("\nTest \"addLast(), removeLast(), getLast()\""); 66 // (01) 將「20」添加到最後一個位置。 失敗的話，拋出異常！ 67 llist.addLast("20"); 68 System.out.println("llist:"+llist); 69 // (02) 將最後一個元素刪除。 失敗的話，拋出異常！ 70 System.out.println("llist.removeLast():"+llist.removeLast()); 71 System.out.println("llist:"+llist); 72 // (03) 獲取最後一個元素。 失敗的話，拋出異常！ 73 System.out.println("llist.getLast():"+llist.getLast()); 74 75 76 System.out.println("\nTest \"offerLast(), pollLast(), peekLast()\""); 77 // (01) 將「20」添加到第一個位置。 返回true。 78 llist.offerLast("20"); 79 System.out.println("llist:"+llist); 80 // (02) 將第一個元素刪除。 失敗的話，返回null。 81 System.out.println("llist.pollLast():"+llist.pollLast()); 82 System.out.println("llist:"+llist); 83 // (03) 獲取第一個元素。 失敗的話，返回null。 84 System.out.println("llist.peekLast():"+llist.peekLast()); 85 86 87 88 // 將第3個元素設置300。不建議在LinkedList中使用此操做，由於效率低！ 89 llist.set(2, "300"); 90 // 獲取第3個元素。不建議在LinkedList中使用此操做，由於效率低！ 91 System.out.println("\nget(3):"+llist.get(2)); 92 93 94 // ---- toArray(T[] a) ---- 95 // 將LinkedList轉行爲數組 96 String[] arr = (String[])llist.toArray(new String[0]); 97 for (String str:arr) 98 System.out.println("str:"+str); 99 100 // 輸出大小 101 System.out.println("size:"+llist.size()); 102 // 清空LinkedList 103 llist.clear(); 104 // 判斷LinkedList是否爲空 105 System.out.println("isEmpty():"+llist.isEmpty()+"\n"); 106 107 } 108 109 /** 110 * 將LinkedList看成 LIFO(後進先出)的堆棧 111 */ 112 private static void useLinkedListAsLIFO() { 113 System.out.println("\nuseLinkedListAsLIFO"); 114 // 新建一個LinkedList 115 LinkedList stack = new LinkedList(); 116 117 // 將1,2,3,4添加到堆棧中 118 stack.push("1"); 119 stack.push("2"); 120 stack.push("3"); 121 stack.push("4"); 122 // 打印「棧」 123 System.out.println("stack:"+stack); 124 125 // 刪除「棧頂元素」 126 System.out.println("stack.pop():"+stack.pop()); 127 128 // 取出「棧頂元素」 129 System.out.println("stack.peek():"+stack.peek()); 130 131 // 打印「棧」 132 System.out.println("stack:"+stack); 133 } 134 135 /** 136 * 將LinkedList看成 FIFO(先進先出)的隊列 137 */ 138 private static void useLinkedListAsFIFO() { 139 System.out.println("\nuseLinkedListAsFIFO"); 140 // 新建一個LinkedList 141 LinkedList queue = new LinkedList(); 142 143 // 將10,20,30,40添加到隊列。每次都是插入到末尾 144 queue.add("10"); 145 queue.add("20"); 146 queue.add("30"); 147 queue.add("40"); 148 // 打印「隊列」 149 System.out.println("queue:"+queue); 150 151 // 刪除(隊列的第一個元素) 152 System.out.println("queue.remove():"+queue.remove()); 153 154 // 讀取(隊列的第一個元素) 155 System.out.println("queue.element():"+queue.element()); 156 157 // 打印「隊列」 158 System.out.println("queue:"+queue); 159 } 160 }
運行結果：
Test "addFirst(), removeFirst(), getFirst()"
llist:[10, 1, 4, 2, 3]
llist.removeFirst():10
llist:[1, 4, 2, 3]
llist.getFirst():1
Test "offerFirst(), pollFirst(), peekFirst()"
llist:[10, 1, 4, 2, 3]
llist.pollFirst():10
llist:[1, 4, 2, 3]
llist.peekFirst():1
Test "addLast(), removeLast(), getLast()"
llist:[1, 4, 2, 3, 20]
llist.removeLast():20
llist:[1, 4, 2, 3]
llist.getLast():3
Test "offerLast(), pollLast(), peekLast()"
llist:[1, 4, 2, 3, 20]
llist.pollLast():20
llist:[1, 4, 2, 3]
llist.peekLast():3
get(3):300
str:1
str:4
str:300
str:3
size:4
isEmpty():true
useLinkedListAsLIFO
stack:[4, 3, 2, 1]
stack.pop():4
stack.peek():3
stack:[3, 2, 1]
useLinkedListAsFIFO
queue:[10, 20, 30, 40]
queue.remove():10
queue.element():20
queue:[20, 30, 40]
更多內容
01. Java 集合系列目錄
03. Java 集合系列03之 ArrayList詳細介紹(源碼解析)和使用示例
相關文章
- 1. Java 集合系列05之 LinkedList詳細介紹(源碼解析)和使用示例
- 2. Java 集合系列05之 LinkedList詳細介紹(源碼解析)和使用示例 Java 集合系列05之 LinkedList詳細介紹(源碼解析)和使用示例
- 3. Java【集合系列】-12- TreeMap詳細介紹(源碼解析)和使用示例
- 4. Java 集合系列10之 HashMap詳細介紹(源碼解析)和使用示例
- 5. Java 集合系列11之 Hashtable詳細介紹(源碼解析)和使用示例
- 6. Java 集合系列16之 HashSet詳細介紹(源碼解析)和使用示例
- 7. Java 集合系列13之 WeakHashMap詳細介紹(源碼解析)和使用示例
- 8. Java 集合系列07之 Stack詳細介紹(源碼解析)和使用示例
- 9. Java 集合系列06之 Vector詳細介紹(源碼解析)和使用示例
- 10. Java 集合系列17之 TreeSet詳細介紹(源碼解析)和使用示例
- 更多相關文章...
- • Spring體系結構詳解 - Spring教程
- • 使用 XSLT 顯示 XML - XML 教程
- • Java Agent入門實戰（一）-Instrumentation介紹與使用
- • 互聯網組織的未來：剖析GitHub員工的任性之源
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Java 集合系列05之 LinkedList詳細介紹(源碼解析)和使用示例
- 2. Java 集合系列05之 LinkedList詳細介紹(源碼解析)和使用示例 Java 集合系列05之 LinkedList詳細介紹(源碼解析)和使用示例
- 3. Java【集合系列】-12- TreeMap詳細介紹(源碼解析)和使用示例
- 4. Java 集合系列10之 HashMap詳細介紹(源碼解析)和使用示例
- 5. Java 集合系列11之 Hashtable詳細介紹(源碼解析)和使用示例
- 6. Java 集合系列16之 HashSet詳細介紹(源碼解析)和使用示例
- 7. Java 集合系列13之 WeakHashMap詳細介紹(源碼解析)和使用示例
- 8. Java 集合系列07之 Stack詳細介紹(源碼解析)和使用示例
- 9. Java 集合系列06之 Vector詳細介紹(源碼解析)和使用示例
- 10. Java 集合系列17之 TreeSet詳細介紹(源碼解析)和使用示例