1 package java.util; 2 3 import java.util.function.Consumer; 4 5 /** 6 * LinkedList是List和Deque接口的双向链表的实现。实现了所有可选List操作，并允许包括null值。 7 * LinkedList既然是通过双向链表去实现的，那么它可以被当作堆栈、队列或双端队列进行操作。并且其顺序访问非常高效，而随机访问效率比较低。 8 * 内部方法，注释会描述为节点的操作(如删除第一个节点)，公开的方法会描述为元素的操作(如删除第一个元素) 9 * 注意，此实现不是同步的。 如果多个线程同时访问一个LinkedList实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。 10 * LinkedList不是线程安全的，如果在多线程中使用（修改），需要在外部作同步处理。 11 * 这通常是通过同步那些用来封装列表的对象来实现的。 12 * 但如果没有这样的对象存在，则该列表需要运用{@link Collections#synchronizedList Collections.synchronizedList}来进行“包装”，该方法最好是在创建列表对象时完成，为了避免对列表进行突发的非同步操作。 13 */ 14 15 public class LinkedList<E> 16 extends AbstractSequentialList<E> 17 implements List<E>, Deque<E>, Cloneable, java.io.Serializable { 18 /** 19 * 元素数量 20 */ 21 transient int size = 0; 22 23 /** 24 * 首结点引用 25 */ 26 transient Node<E> first; 27 28 /** 29 * 尾节点引用 30 */ 31 transient Node<E> last; 32 33 /** 34 * 无参构造方法 35 */ 36 public LinkedList() { 37 } 38 39 /** 40 * 通过一个集合初始化LinkedList，元素顺序有这个集合的迭代器返回顺序决定 41 * 42 * @param c 其元素将被放入此列表中的集合 43 * @throws NullPointerException 如果指定的集合是空的 44 */ 45 public LinkedList(Collection<? extends E> c) { 46 // 调用无参构造函数 47 this(); 48 // 添加集合中所有的元素 49 addAll(c); 50 } 51 52 /** 53 * 头插入，即将节点值为e的节点设置为链表首节点，内部使用 54 */ 55 private void linkFirst(E e) { 56 //获取当前首结点引用 57 final Node<E> f = first; 58 //构建一个prev值为null,节点值为e,next值为f的新节点newNode 59 final Node<E> newNode = new Node<>(null, e, f); 60 //将newNode作为首节点 61 first = newNode; 62 //如果原首节点为null，即原链表为null，则链表尾节点也设置为newNode 63 if (f == null) 64 last = newNode; 65 else //否则，原首节点的prev设置为newNode 66 f.prev = newNode; 67 size++; //长度+1 68 modCount++; //修改次数+1 69 } 70 71 /** 72 * 尾插入，即将节点值为e的节点设置为链表的尾节点 73 */ 74 void linkLast(E e) { 75 // 获取当前尾结点引用 76 final Node<E> l = last; 77 //构建一个prev值为l,节点值为e,next值为null的新节点newNode 78 final Node<E> newNode = new Node<>(l, e, null); 79 //将newNode作为尾节点 80 last = newNode; 81 //如果原尾节点为null，即原链表为null，则链表首节点也设置为newNode 82 if (l == null) 83 first = newNode; 84 else //否则，原尾节点的next设置为newNode 85 l.next = newNode; 86 size++; 87 modCount++; 88 } 89 90 /** 91 * 中间插入，在非空节点succ之前插入节点值e 92 */ 93 void linkBefore(E e, Node<E> succ) { 94 // assert succ != null; 95 final Node<E> pred = succ.prev; 96 //构建一个prev值为succ.prev,节点值为e,next值为succ的新节点newNode 97 final Node<E> newNode = new Node<>(pred, e, succ); 98 //设置newNode为succ的前节点 99 succ.prev = newNode; 100 //如果succ.prev为null，即如果succ为首节点，则将newNode设置为首节点 101 if (pred == null) 102 first = newNode; 103 else //如果succ不是首节点 104 pred.next = newNode; 105 size++; 106 modCount++; 107 } 108 109 /** 110 * 删除首结点，返回存储的元素，内部使用 111 */ 112 private E unlinkFirst(Node<E> f) { 113 // 获取首结点存储的元素 114 final E element = f.item; 115 // 获取首结点的后继结点 116 final Node<E> next = f.next; 117 // 删除首结点 118 f.item = null; 119 f.next = null; //便于垃圾回收期清理 120 // 原来首结点的后继结点设为首结点 121 first = next; 122 // 如果原来首结点的后继结点为空，则尾结点设为null 123 // 否则，原来首结点的后继结点的前驱结点设为null 124 if (next == null) 125 last = null; 126 else 127 next.prev = null; 128 size--; 129 modCount++; 130 // 返回原来首结点存储的元素 131 return element; 132 } 133 134 /** 135 * 删除尾结点，返回存储的元素，内部使用 136 */ 137 private E unlinkLast(Node<E> l) { 138 // 获取尾结点存储的元素 139 final E element = l.item; 140 // 获取尾结点的前驱结点 141 final Node<E> prev = l.prev; 142 // 删除尾结点 143 l.item = null; 144 l.prev = null; // help GC 145 // 原来尾结点的前驱结点设为尾结点 146 last = prev; 147 // 如果原来尾结点的前驱结点为空，则首结点设为null 148 // 否则，原来尾结点的前驱结点的后继结点设为null 149 if (prev == null) 150 first = null; 151 else 152 prev.next = null; 153 size--; 154 modCount++; 155 // 返回原来尾结点存储的元素 156 return element; 157 } 158 159 /** 160 * 删除指定非空结点，返回存储的元素 161 */ 162 E unlink(Node<E> x) { 163 // 获取指定非空结点存储的元素 164 final E element = x.item; 165 // 获取指定非空结点的后继结点 166 final Node<E> next = x.next; 167 // 获取指定非空结点的前驱结点 168 final Node<E> prev = x.prev; 169 170 /** 171 * 如果指定非空结点的前驱结点为空，则指定非空结点的后继结点设为首结点 172 * 否则，指定非空结点的后继结点设为指定非空结点的前驱结点的后继结点， 173 * 指定非空结点的前驱结点设为null 174 */ 175 if (prev == null) { 176 first = next; 177 } else { 178 prev.next = next; 179 x.prev = null; 180 } 181 182 /** 183 * 如果指定非空结点的后继结点为空，则指定非空结点的前驱结点设为尾结点 184 * 否则，指定非空结点的前驱结点设为指定非空结点的后继结点的前驱结点， 185 * 指定非空结点的后继结点设为null 186 */ 187 if (next == null) { 188 last = prev; 189 } else { 190 next.prev = prev; 191 x.next = null; 192 } 193 194 // 指定非空结点存储的元素设为null 195 x.item = null; 196 size--; 197 modCount++; 198 // 返回指定非空结点存储的元素 199 return element; 200 } 201 202 /** 203 * 获取首结点存储的元素 204 * 205 * @return 首结点存储的元素 206 * @throws NoSuchElementException 如果链表为空 207 */ 208 public E getFirst() { 209 // 获取首结点引用 210 final Node<E> f = first; 211 // 如果首结点为空，则抛出无该元素异常 212 if (f == null) 213 throw new NoSuchElementException(); 214 // 返回首结点存储的元素 215 return f.item; 216 } 217 218 /** 219 * 获取尾结点存储的元素 220 * 221 * @return 尾结点存储的元素 222 * @throws NoSuchElementException 如果链表为空 223 */ 224 public E getLast() { 225 // 获取尾结点引用 226 final Node<E> l = last; 227 // 如果尾结点为空，则抛出无该元素异常 228 if (l == null) 229 throw new NoSuchElementException(); 230 // 返回尾结点存储的元素 231 return l.item; 232 } 233 234 /** 235 * 删除首结点，返回存储的元素 236 * 237 * @return 首结点存储的元素 238 * @throws NoSuchElementException 如果链表为空 239 */ 240 public E removeFirst() { 241 // 获取首结点引用 242 final Node<E> f = first; 243 // 如果首结点为空，则抛出无该元素异常 244 if (f == null) 245 throw new NoSuchElementException(); 246 // 删除首结点，返回存储的元素 247 return unlinkFirst(f); 248 } 249 250 /** 251 * 删除尾结点，返回存储的元素 252 * 253 * @return 尾结点存储的元素 254 * @throws NoSuchElementException 如果链表为空 255 */ 256 public E removeLast() { 257 // 获取尾结点引用 258 final Node<E> l = last; 259 // 如果尾结点为空，则抛出无该元素异常 260 if (l == null) 261 throw new NoSuchElementException(); 262 // 删除尾结点，返回存储的元素 263 return unlinkLast(l); 264 } 265 266 /** 267 * 头部插入指定元素 268 * 269 * @param e 要添加的元素 270 */ 271 public void addFirst(E e) { 272 // 通过头插法来插入指定元素 273 linkFirst(e); 274 } 275 276 /** 277 * 尾部插入指定元素，该方法等价于add() 278 * 279 * @param e the element to add 280 */ 281 public void addLast(E e) { 282 linkLast(e); 283 } 284 285 /** 286 * 判断是否包含指定元素 287 * 288 * @param o 判断链表是否包含的元素 289 * @return {@code true} 如果链表包含指定的元素 290 */ 291 public boolean contains(Object o) { 292 //返回指定元素的索引位置，不存在就返回-1，然后比较返回bool值 293 return indexOf(o) != -1; 294 } 295 296 /** 297 * 获取元素数量 298 * 299 * @return 元素数量 300 */ 301 public int size() { 302 return size; 303 } 304 305 /** 306 * 插入指定元素，返回操作结果,默认添加到末尾作为最后一个元素 307 * 308 * @param e 要添加到此链表中的元素 309 * @return {@code true} (as specified by {@link Collection#add}) 310 */ 311 public boolean add(E e) { 312 // 通过尾插法来插入指定元素 313 linkLast(e); 314 return true; 315 } 316 317 /** 318 * 删除指定元素，默认从first节点开始，删除第一次出现的那个元素 319 * 320 * @param o 要从该列表中删除的元素（如果存在） 321 * @return {@code true} 如果这个列表包含指定的元素 322 */ 323 public boolean remove(Object o) { 324 //会根据是否为null分开处理。若值不是null，会用到对象的equals()方法 325 if (o == null) { 326 // 遍历链表，查找到指定元素后删除该结点，返回true 327 for (Node<E> x = first; x != null; x = x.next) { 328 if (x.item == null) { 329 unlink(x); 330 return true; 331 } 332 } 333 } else { 334 for (Node<E> x = first; x != null; x = x.next) { 335 if (o.equals(x.item)) { 336 unlink(x); 337 return true; 338 } 339 } 340 } 341 // 查找失败 342 return false; 343 } 344 345 /** 346 * 将集合插入到链表尾部，即开始索引位置为size 347 * 348 * @param c 包含要添加到此链表中的元素的集合 349 * @return {@code true} 如果该链表因添加而改变 350 * @throws NullPointerException 如果指定的集合是空的 351 */ 352 public boolean addAll(Collection<? extends E> c) { 353 return addAll(size, c); 354 } 355 356 /** 357 * 将集合从指定位置开始插入 358 * 359 * @param index 在哪个索引处前插入指定集合中的第一个元素 360 * @param c 包含要添加到此链表中的元素的集合 361 * @return {@code true} 如果该链表因添加而改变 362 * @throws IndexOutOfBoundsException {@inheritDoc} 363 * @throws NullPointerException 如果指定的集合是空的 364 */ 365 public boolean addAll(int index, Collection<? extends E> c) { 366 //检查索引是否正确（0<=index<=size） 367 checkPositionIndex(index); 368 //得到元素数组 369 Object[] a = c.toArray(); 370 //得到元素个数 371 int numNew = a.length; 372 //若没有元素要添加，直接返回false 373 if (numNew == 0) 374 return false; 375 //succ指向当前需要插入节点的位置，pred指向其前一个节点 376 Node<E> pred, succ; 377 //如果是在末尾开始添加，当前节点后一个节点初始化为null，前一个节点为尾节点 378 if (index == size) { 379 succ = null; 380 pred = last; 381 } else { //如果不是从末尾开始添加，当前位置的节点为指定位置的节点，前一个节点为要添加的节点的前一个节点 382 succ = node(index); 383 pred = succ.prev; 384 } 385 //遍历数组并添加到列表中 386 for (Object o : a) { 387 @SuppressWarnings("unchecked") E e = (E) o; 388 //将元素值e，前继节点pred“封装”为一个新节点newNode 389 Node<E> newNode = new Node<>(pred, e, null); 390 //如果原链表为null，则新插入的节点作为链表首节点 391 if (pred == null) 392 first = newNode; 393 else 394 pred.next = newNode; //如果存在前节点，前节点会向后指向新加的节点 395 pred = newNode; //pred指针向后移动，指向下一个需插入节点位置的前一个节点 396 } 397 //如果是从最后开始添加的，则最后添加的节点成为尾节点 398 if (succ == null) { 399 last = pred; 400 } else { 401 pred.next = succ; //如果不是从最后开始添加的，则最后添加的节点向后指向之前得到的后续第一个节点 402 succ.prev = pred; //当前，后续的第一个节点也应改为向前指向最后一个添加的节点 403 } 404 405 size += numNew; 406 modCount++; 407 return true; 408 } 409 410 /** 411 * 删除所有元素 412 */ 413 public void clear() { 414 //遍历链表，删除所有结点,方便gc回收垃圾 415 for (Node<E> x = first; x != null; ) { 416 Node<E> next = x.next; 417 x.item = null; 418 x.next = null; 419 x.prev = null; 420 x = next; 421 } 422 // 首尾结点置空 423 first = last = null; 424 // 元素数量置0 425 size = 0; 426 modCount++; 427 } 428 429 430 // 位置访问操作 431 432 /** 433 * 获取指定位置的元素 434 * 435 * @param index 要返回的元素的索引 436 * @return 该链表中指定位置的元素 437 * @throws IndexOutOfBoundsException {@inheritDoc} 438 */ 439 public E get(int index) { 440 // 判断指定位置是否合法 441 checkElementIndex(index); 442 // 返回指定位置的元素 443 return node(index).item; 444 } 445 446 /** 447 * 修改指定位置的元素，返回之前元素 448 * 449 * @param index 要替换的元素的索引 450 * @param element 要存储在指定位置的元素 451 * @return 之前在指定位置的元素 452 * @throws IndexOutOfBoundsException {@inheritDoc} 453 */ 454 public E set(int index, E element) { 455 // 判断指定位置是否合法 456 checkElementIndex(index); 457 // 获取指定位置的结点 458 Node<E> x = node(index); 459 // 获取该结点存储的元素 460 E oldVal = x.item; 461 // 修改该结点存储的元素 462 x.item = element; 463 // 返回该结点存储的之前的元素 464 return oldVal; 465 } 466 467 /** 468 * 在指定位置前插入指定元素 469 * 470 * @param index 指定元素将被插入的索引 471 * @param element 要插入的元素 472 * @throws IndexOutOfBoundsException {@inheritDoc} 473 */ 474 public void add(int index, E element) { 475 // 判断指定位置是否合法 476 checkPositionIndex(index); 477 // 如果指定位置在尾部，则通过尾插法来插入指定元素 478 if (index == size) 479 linkLast(element); 480 else //如果指定位置不是尾部，则添加到指定位置前 481 linkBefore(element, node(index)); 482 } 483 484 /** 485 * 删除指定位置的元素，返回之前元素 486 * 487 * @param index 要删除的元素的索引 488 * @return 之前在指定位置的元素 489 * @throws IndexOutOfBoundsException {@inheritDoc} 490 */ 491 public E remove(int index) { 492 // 判断指定位置是否合法 493 checkElementIndex(index); 494 // 删除指定位置的结点，返回之前元素 495 return unlink(node(index)); 496 } 497 498 /** 499 * 判断指定位置是否合法 500 */ 501 private boolean isElementIndex(int index) { 502 return index >= 0 && index < size; 503 } 504 505 /** 506 * 判断迭代器遍历时或插入元素时指定位置是否合法 507 */ 508 private boolean isPositionIndex(int index) { 509 return index >= 0 && index <= size; 510 } 511 512 /** 513 * 获取越界异常信息 514 */ 515 private String outOfBoundsMsg(int index) { 516 return "Index: " + index + ", Size: " + size; 517 } 518 519 /** 520 * 判断指定位置是否合法 521 * 522 * @param index 523 */ 524 private void checkElementIndex(int index) { 525 if (!isElementIndex(index)) 526 throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); 527 } 528 529 /** 530 * 判断指定位置是否合法 531 * 532 * @param index 533 */ 534 private void checkPositionIndex(int index) { 535 if (!isPositionIndex(index)) 536 throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); 537 } 538 539 /** 540 * 获取指定下标的结点，index从0开始 541 */ 542 Node<E> node(int index) { 543 // 如果指定下标<一半元素数量，则从首结点开始遍历 544 // 否则，从尾结点开始遍历 545 if (index < (size >> 1)) { 546 Node<E> x = first; 547 for (int i = 0; i < index; i++) 548 x = x.next; 549 return x; 550 } else { 551 Node<E> x = last; 552 for (int i = size - 1; i > index; i--) 553 x = x.prev; 554 return x; 555 } 556 } 557 558 // 查询操作 559 560 /** 561 * 获取顺序下首次出现指定元素的位置 562 * 如果返回结果是-1，则表示不存在该元素 563 * 564 * @param o 要查找的元素 565 * @return the index of the first occurrence of the specified element in 566 * this list, or -1 if this list does not contain the element 567 */ 568 public int indexOf(Object o) { 569 int index = 0; 570 if (o == null) { 571 // 遍历链表，顺序查找指定元素 572 for (Node<E> x = first; x != null; x = x.next) { 573 if (x.item == null) 574 return index; 575 index++; 576 } 577 } else { 578 for (Node<E> x = first; x != null; x = x.next) { 579 if (o.equals(x.item)) 580 return index; 581 index++; 582 } 583 } 584 return -1; 585 } 586 587 /** 588 * 获取逆序下首次出现指定元素的位置 589 * 如果返回结果是-1，则表示不存在该元素 590 * 591 * @param o 要查找的元素 592 * @return the index of the last occurrence of the specified element in 593 * this list, or -1 if this list does not contain the element 594 */ 595 public int lastIndexOf(Object o) { 596 int index = size; 597 if (o == null) { 598 // 遍历链表，逆序查找指定元素 599 for (Node<E> x = last; x != null; x = x.prev) { 600 index--; 601 if (x.item == null) 602 return index; 603 } 604 } else { 605 for (Node<E> x = last; x != null; x = x.prev) { 606 index--; 607 if (o.equals(x.item)) 608 return index; 609 } 610 } 611 return -1; 612 } 613 614 // 队列操作 615 616 /** 617 * 出队（从前端），获得第一个元素，不存在会返回null，不会删除元素（节点） 618 * 获取首元素 619 * 620 * @return the head of this list, or {@code null} 如果链表为空 621 * @since 1.5 622 */ 623 public E peek() { 624 final Node<E> f = first; 625 // 如果首结点为空，则返回null 626 // 否则，返回首结点存储的元素 627 return (f == null) ? null : f.item; 628 } 629 630 /** 631 * 出队（从前端），不删除元素，若为null会抛出异常而不是返回null 632 * 获取首元素 633 * 634 * @return the head of this list 635 * @throws NoSuchElementException 如果链表为空 636 * @since 1.5 637 */ 638 public E element() { 639 // 返回首结点存储的元素 640 return getFirst(); 641 } 642 643 /** 644 * 出队（从前端），如果不存在会返回null，存在的话会返回值并移除这个元素（节点） 645 * 获取并删除首元素 646 * 647 * @return the head of this list, or {@code null} 如果链表为空 648 * @since 1.5 649 */ 650 public E poll() { 651 // 获取首结点引用 652 final Node<E> f = first; 653 // 如果首结点为空，则返回null 654 // 否则，删除首结点，返回首结点存储的元素 655 return (f == null) ? null : unlinkFirst(f); 656 } 657 658 /** 659 * 出队（从前端），如果不存在会抛出异常而不是返回null，存在的话会返回值并移除这个元素（节点） 660 * 获取并删除首元素 661 * 662 * @return the head of this list 663 * @throws NoSuchElementException 如果链表为空 664 * @since 1.5 665 */ 666 public E remove() { 667 // 删除首结点，返回首结点存储的元素 668 return removeFirst(); 669 } 670 671 /** 672 * 入队（从后端），始终返回true 673 * 674 * @param e the element to add 675 * @return {@code true} (as specified by {@link Queue#offer}) 676 * @since 1.5 677 */ 678 public boolean offer(E e) { 679 // 通过尾插法插入指定元素，返回操作结果 680 return add(e); 681 } 682 683 // 双端队列操作 684 685 /** 686 * 入队（从前端），始终返回true 687 * 688 * @param e 要插入的元素 689 * @return {@code true} (as specified by {@link Deque#offerFirst}) 690 * @since 1.6 691 */ 692 public boolean offerFirst(E e) { 693 // 通过尾插法来插入指定元素 694 addFirst(e); 695 return true; 696 } 697 698 /** 699 * 入队（从后端），始终返回true 700 * 701 * @param e 要插入的元素 702 * @return {@code true} (as specified by {@link Deque#offerLast}) 703 * @since 1.6 704 */ 705 public boolean offerLast(E e) { 706 // 通过尾插法来插入指定元素 707 addLast(e); 708 return true; 709 } 710 711 /** 712 * 出队（从后端），获得最后一个元素，不存在会返回null，不会删除元素（节点） 713 * 714 * @return the first element of this list, or {@code null} 715 * 如果链表为空 716 * @since 1.6 717 */ 718 public E peekFirst() { 719 // 获取首结点引用 720 final Node<E> f = first; 721 // 如果首结点为空，则返回null 722 // 否则，返回首结点存储的元素 723 return (f == null) ? null : f.item; 724 } 725 726 /** 727 * 出队（从后端），获得最后一个元素，不存在会返回null，不会删除元素（节点） 728 * 729 * @return the last element of this list, or {@code null} 730 * 如果链表为空 731 * @since 1.6 732 */ 733 public E peekLast() { 734 // 获取尾结点引用 735 final Node<E> l = last; 736 // 如果尾结点为空，则返回null 737 // 否则，返回尾结点存储的元素 738 return (l == null) ? null : l.item; 739 } 740 741 /** 742 * 出队（从前端），获得第一个元素，不存在会返回null，会删除元素（节点） 743 * 744 * @return the first element of this list, or {@code null} if 745 * this list is empty 746 * @since 1.6 747 */ 748 public E pollFirst() { 749 // 获取首结点引用 750 final Node<E> f = first; 751 // 如果首结点为空，则返回null 752 // 否则，删除首结点，返回首结点存储的元素 753 return (f == null) ? null : unlinkFirst(f); 754 } 755 756 /** 757 * 出队（从后端），获得最后一个元素，不存在会返回null，会删除元素（节点） 758 * 759 * @return the last element of this list, or {@code null} if 760 * this list is empty 761 * @since 1.6 762 */ 763 public E pollLast() { 764 // 获取尾结点引用 765 final Node<E> l = last; 766 // 如果尾结点为空，则返回null 767 // 否则，删除尾结点，返回尾结点存储的元素 768 return (l == null) ? null : unlinkLast(l); 769 } 770 771 /** 772 * 入栈，从前面添加 773 * 774 * @param e the element to push 775 * @since 1.6 776 */ 777 public void push(E e) { 778 // 通过头插法来插入指定元素 779 addFirst(e); 780 } 781 782 /** 783 * 出栈，返回栈顶元素，从前面移除（会删除） 784 * 785 * @return the element at the front of this list (which is the top 786 * of the stack represented by this list) 787 * @throws NoSuchElementException 如果链表为空 788 * @since 1.6 789 */ 790 public E pop() { 791 // 删除首结点，返回首结点存储的元素 792 return removeFirst(); 793 } 794 795 /** 796 * 删除顺序下首次出现的指定元素，返回操作结果 797 * 798 * @param o 要从该列表中删除的元素（如果存在） 799 * @return {@code true} 如果链表包含指定的元素 800 * @since 1.6 801 */ 802 public boolean removeFirstOccurrence(Object o) { 803 // 删除顺序下首次出现的指定元素对应的结点，返回操作结果 804 return remove(o); 805 } 806 807 /** 808 * 删除逆序下首次出现的指定元素，返回操作结果 809 * 810 * @param o 要从该列表中删除的元素（如果存在） 811 * @return {@code true} 如果链表包含指定的元素 812 * @since 1.6 813 */ 814 public boolean removeLastOccurrence(Object o) { 815 //由于LinkedList中允许存放null，因此下面通过两种情况来分别处理 816 if (o == null) { 817 // 遍历链表，从尾结点开始查找指定元素 818 // 如果查找成功，删除该结点，返回true 819 for (Node<E> x = last; x != null; x = x.prev) { 820 if (x.item == null) { 821 unlink(x); 822 return true; 823 } 824 } 825 } else { 826 for (Node<E> x = last; x != null; x = x.prev) { 827 if (o.equals(x.item)) { 828 unlink(x); 829 return true; 830 } 831 } 832 } 833 // 查找失败 834 return false; 835 } 836 837 /** 838 * Returns a list-iterator of the elements in this list (in proper 839 * sequence), starting at the specified position in the list. 840 * Obeys the general contract of {@code List.listIterator(int)}.<p> 841 * <p> 842 * The list-iterator is <i>fail-fast</i>: if the list is structurally 843 * modified at any time after the Iterator is created, in any way except 844 * through the list-iterator‘s own {@code remove} or {@code add} 845 * methods, the list-iterator will throw a 846 * {@code ConcurrentModificationException}. Thus, in the face of 847 * concurrent modification, the iterator fails quickly and cleanly, rather 848 * than risking arbitrary, non-deterministic behavior at an undetermined 849 * time in the future. 850 * 851 * @param index index of the first element to be returned from the 852 * list-iterator (by a call to {@code next}) 853 * @return a ListIterator of the elements in this list (in proper 854 * sequence), starting at the specified position in the list 855 * @throws IndexOutOfBoundsException {@inheritDoc} 856 * @see List#listIterator(int) 857 */ 858 public ListIterator<E> listIterator(int index) { 859 checkPositionIndex(index); 860 return new ListItr(index); 861 } 862 863 private class ListItr implements ListIterator<E> { 864 private Node<E> lastReturned; 865 private Node<E> next; 866 private int nextIndex; 867 private int expectedModCount = modCount; 868 869 ListItr(int index) { 870 // assert isPositionIndex(index); 871 next = (index == size) ? null : node(index); 872 nextIndex = index; 873 } 874 875 public boolean hasNext() { 876 return nextIndex < size; 877 } 878 879 public E next() { 880 checkForComodification(); 881 if (!hasNext()) 882 throw new NoSuchElementException(); 883 884 lastReturned = next; 885 next = next.next; 886 nextIndex++; 887 return lastReturned.item; 888 } 889 890 public boolean hasPrevious() { 891 return nextIndex > 0; 892 } 893 894 public E previous() { 895 checkForComodification(); 896 if (!hasPrevious()) 897 throw new NoSuchElementException(); 898 899 lastReturned = next = (next == null) ? last : next.prev; 900 nextIndex--; 901 return lastReturned.item; 902 } 903 904 public int nextIndex() { 905 return nextIndex; 906 } 907 908 public int previousIndex() { 909 return nextIndex - 1; 910 } 911 912 public void remove() { 913 checkForComodification(); 914 if (lastReturned == null) 915 throw new IllegalStateException(); 916 917 Node<E> lastNext = lastReturned.next; 918 unlink(lastReturned); 919 if (next == lastReturned) 920 next = lastNext; 921 else 922 nextIndex--; 923 lastReturned = null; 924 expectedModCount++; 925 } 926 927 public void set(E e) { 928 if (lastReturned == null) 929 throw new IllegalStateException(); 930 checkForComodification(); 931 lastReturned.item = e; 932 } 933 934 public void add(E e) { 935 checkForComodification(); 936 lastReturned = null; 937 if (next == null) 938 linkLast(e); 939 else 940 linkBefore(e, next); 941 nextIndex++; 942 expectedModCount++; 943 } 944 945 public void forEachRemaining(Consumer<? super E> action) { 946 Objects.requireNonNull(action); 947 while (modCount == expectedModCount && nextIndex < size) { 948 action.accept(next.item); 949 lastReturned = next; 950 next = next.next; 951 nextIndex++; 952 } 953 checkForComodification(); 954 } 955 956 final void checkForComodification() { 957 if (modCount != expectedModCount) 958 throw new ConcurrentModificationException(); 959 } 960 } 961 962 /** 963 * 节点的数据结构，包含前后节点的引用和当前节点 964 * 965 * @param <E> 966 */ 967 private static class Node<E> { 968 // 存储的元素 969 E item; 970 // 后继结点 971 Node<E> next; 972 // 前驱结点 973 Node<E> prev; 974 975 // 前驱结点、存储的元素和后继结点作为参数的构造方法 976 Node(Node<E> prev, E element, Node<E> next) { 977 this.item = element; 978 this.next = next; 979 this.prev = prev; 980 } 981 } 982 983 /** 984 * 返回迭代器 985 * 986 * @since 1.6 987 */ 988 public Iterator<E> descendingIterator() { 989 return new DescendingIterator(); 990 } 991 992 /** 993 * 因为采用链表实现，所以迭代器很简单 994 */ 995 private class DescendingIterator implements Iterator<E> { 996 private final ListItr itr = new ListItr(size()); 997 998 public boolean hasNext() { 999 return itr.hasPrevious(); 1000 } 1001 1002 public E next() { 1003 return itr.previous(); 1004 } 1005 1006 public void remove() { 1007 itr.remove(); 1008 } 1009 } 1010 1011 /** 1012 * 父类克隆方法 1013 */ 1014 @SuppressWarnings("unchecked") 1015 private LinkedList<E> superClone() { 1016 try { 1017 return (LinkedList<E>) super.clone(); 1018 } catch (CloneNotSupportedException e) { 1019 throw new InternalError(e); 1020 } 1021 } 1022 1023 /** 1024 * 克隆，浅拷贝 1025 * 1026 * @return a shallow copy of this {@code LinkedList} instance 1027 */ 1028 public Object clone() { 1029 LinkedList<E> clone = superClone(); 1030 1031 // 链表初始化 1032 clone.first = clone.last = null; 1033 clone.size = 0; 1034 clone.modCount = 0; 1035 1036 // 插入结点 1037 for (Node<E> x = first; x != null; x = x.next) 1038 clone.add(x.item); 1039 // 返回克隆后的对象引用 1040 return clone; 1041 } 1042 1043 /** 1044 * Returns an array containing all of the elements in this list 1045 * in proper sequence (from first to last element). 1046 * <p> 1047 * <p>The returned array will be "safe" in that no references to it are 1048 * maintained by this list. (In other words, this method must allocate 1049 * a new array). The caller is thus free to modify the returned array. 1050 * <p> 1051 * <p>This method acts as bridge between array-based and collection-based 1052 * APIs. 1053 * 1054 * @return an array containing all of the elements in this list 1055 * in proper sequence 1056 */ 1057 public Object[] toArray() { 1058 Object[] result = new Object[size]; 1059 int i = 0; 1060 for (Node<E> x = first; x != null; x = x.next) 1061 result[i++] = x.item; 1062 return result; 1063 } 1064 1065 /** 1066 * Returns an array containing all of the elements in this list in 1067 * proper sequence (from first to last element); the runtime type of 1068 * the returned array is that of the specified array. If the list fits 1069 * in the specified array, it is returned therein. Otherwise, a new 1070 * array is allocated with the runtime type of the specified array and 1071 * the size of this list. 1072 * <p> 1073 * <p>If the list fits in the specified array with room to spare (i.e., 1074 * the array has more elements than the list), the element in the array 1075 * immediately following the end of the list is set to {@code null}. 1076 * (This is useful in determining the length of the list <i>only</i> if 1077 * the caller knows that the list does not contain any null elements.) 1078 * <p> 1079 * <p>Like the {@link #toArray()} method, this method acts as bridge between 1080 * array-based and collection-based APIs. Further, this method allows 1081 * precise control over the runtime type of the output array, and may, 1082 * under certain circumstances, be used to save allocation costs. 1083 * <p> 1084 * <p>Suppose {@code x} is a list known to contain only strings. 1085 * The following code can be used to dump the list into a newly 1086 * allocated array of {@code String}: 1087 * <p> 1088 * <pre> 1089 * String[] y = x.toArray(new String[0]);</pre> 1090 * <p> 1091 * Note that {@code toArray(new Object[0])} is identical in function to 1092 * {@code toArray()}. 1093 * 1094 * @param a the array into which the elements of the list are to 1095 * be stored, if it is big enough; otherwise, a new array of the 1096 * same runtime type is allocated for this purpose. 1097 * @return an array containing the elements of the list 1098 * @throws ArrayStoreException if the runtime type of the specified array 1099 * is not a supertype of the runtime type of every element in 1100 * this list 1101 * @throws NullPointerException if the specified array is null 1102 */ 1103 @SuppressWarnings("unchecked") 1104 public <T> T[] toArray(T[] a) { 1105 if (a.length < size) 1106 a = (T[]) java.lang.reflect.Array.newInstance( 1107 a.getClass().getComponentType(), size); 1108 int i = 0; 1109 Object[] result = a; 1110 for (Node<E> x = first; x != null; x = x.next) 1111 result[i++] = x.item; 1112 1113 if (a.length > size) 1114 a[size] = null; 1115 1116 return a; 1117 } 1118 1119 private static final long serialVersionUID = 876323262645176354L; 1120 1121 /** 1122 * 序列化 1123 */ 1124 private void writeObject(java.io.ObjectOutputStream s) 1125 throws java.io.IOException { 1126 // 默认序列化 1127 s.defaultWriteObject(); 1128 1129 // 写入元素数量 1130 s.writeInt(size); 1131 1132 // 遍历链表，写入所有元素 1133 for (Node<E> x = first; x != null; x = x.next) 1134 s.writeObject(x.item); 1135 } 1136 1137 /** 1138 * 反序列化 1139 */ 1140 @SuppressWarnings("unchecked") 1141 private void readObject(java.io.ObjectInputStream s) 1142 throws java.io.IOException, ClassNotFoundException { 1143 // 默认反序列化 1144 s.defaultReadObject(); 1145 1146 // 读取元素数量 1147 int size = s.readInt(); 1148 1149 // 遍历链表，读取所有元素并尾部插入 1150 for (int i = 0; i < size; i++) 1151 linkLast((E) s.readObject()); 1152 } 1153 1154 /** 1155 * Creates a <em><a href="Spliterator.html#binding">late-binding</a></em> 1156 * and <em>fail-fast</em> {@link Spliterator} over the elements in this 1157 * list. 1158 * <p> 1159 * <p>The {@code Spliterator} reports {@link Spliterator#SIZED} and 1160 * {@link Spliterator#ORDERED}. Overriding implementations should document 1161 * the reporting of additional characteristic values. 1162 * 1163 * @return a {@code Spliterator} over the elements in this list 1164 * @implNote The {@code Spliterator} additionally reports {@link Spliterator#SUBSIZED} 1165 * and implements {@code trySplit} to permit limited parallelism.. 1166 * @since 1.8 1167 */ 1168 @Override 1169 public Spliterator<E> spliterator() { 1170 return new LLSpliterator<E>(this, -1, 0); 1171 } 1172 1173 /** 1174 * A customized variant of Spliterators.IteratorSpliterator 1175 */ 1176 static final class LLSpliterator<E> implements Spliterator<E> { 1177 static final int BATCH_UNIT = 1 << 10; // batch array size increment 1178 static final int MAX_BATCH = 1 << 25; // max batch array size; 1179 final LinkedList<E> list; // null OK unless traversed 1180 Node<E> current; // current node; null until initialized 1181 int est; // size estimate; -1 until first needed 1182 int expectedModCount; // initialized when est set 1183 int batch; // batch size for splits 1184 1185 LLSpliterator(LinkedList<E> list, int est, int expectedModCount) { 1186 this.list = list; 1187 this.est = est; 1188 this.expectedModCount = expectedModCount; 1189 } 1190 1191 final int getEst() { 1192 int s; // force initialization 1193 final LinkedList<E> lst; 1194 if ((s = est) < 0) { 1195 if ((lst = list) == null) 1196 s = est = 0; 1197 else { 1198 expectedModCount = lst.modCount; 1199 current = lst.first; 1200 s = est = lst.size; 1201 } 1202 } 1203 return s; 1204 } 1205 1206 public long estimateSize() { 1207 return (long) getEst(); 1208 } 1209 1210 public Spliterator<E> trySplit() { 1211 Node<E> p; 1212 int s = getEst(); 1213 if (s > 1 && (p = current) != null) { 1214 int n = batch + BATCH_UNIT; 1215 if (n > s) 1216 n = s; 1217 if (n > MAX_BATCH) 1218 n = MAX_BATCH; 1219 Object[] a = new Object[n]; 1220 int j = 0; 1221 do { 1222 a[j++] = p.item; 1223 } while ((p = p.next) != null && j < n); 1224 current = p; 1225 batch = j; 1226 est = s - j; 1227 return Spliterators.spliterator(a, 0, j, Spliterator.ORDERED); 1228 } 1229 return null; 1230 } 1231 1232 public void forEachRemaining(Consumer<? super E> action) { 1233 Node<E> p; 1234 int n; 1235 if (action == null) throw new NullPointerException(); 1236 if ((n = getEst()) > 0 && (p = current) != null) { 1237 current = null; 1238 est = 0; 1239 do { 1240 E e = p.item; 1241 p = p.next; 1242 action.accept(e); 1243 } while (p != null && --n > 0); 1244 } 1245 if (list.modCount != expectedModCount) 1246 throw new ConcurrentModificationException(); 1247 } 1248 1249 public boolean tryAdvance(Consumer<? super E> action) { 1250 Node<E> p; 1251 if (action == null) throw new NullPointerException(); 1252 if (getEst() > 0 && (p = current) != null) { 1253 --est; 1254 E e = p.item; 1255 current = p.next; 1256 action.accept(e); 1257 if (list.modCount != expectedModCount) 1258 throw new ConcurrentModificationException(); 1259 return true; 1260 } 1261 return false; 1262 } 1263 1264 public int characteristics() { 1265 return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED; 1266 } 1267 } 1268 1269 }