查看: 720|回复: 0

[Java语言] LinkedList的实现原理

发表于 2017-1-5 12:00:00
1. LinkedList概述:

List 接口的链接列表实现。实现所有可选的列表操作,并且允许所有元素(包括 null)。除了实现 List 接口外,LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。
此类实现 Deque 接口,为 add、poll 提供先进先出队列操作,以及其他堆栈和双端队列操作。
所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头或结尾遍历列表(从靠近指定索引的一端)。
注意,此实现不是同步的。如果多个线程同时访问一个链接列表,而其中至少一个线程从结构上修改了该列表,则它必须 保持外部同步。(结构修改指添加或删除一个或多个元素的任何操作;仅设置元素的值不是结构修改。)这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象,则应该使用 Collections.synchronizedList 方法来“包装”该列表。最好在创建时完成这一操作,以防止对列表进行意外的不同步访问,如下所示:
List list = Collections.synchronizedList(new LinkedList(...));
此类的 iterator 和 listIterator 方法返回的迭代器是快速失败 的:在迭代器创建之后,如果从结构上对列表进行修改,除非通过迭代器自身的 remove 或 add 方法,其他任何时间任何方式的修改,迭代器都将抛出 ConcurrentModificationException。因此,面对并发的修改,迭代器很快就会完全失败,而不冒将来不确定的时间任意发生不确定行为的风险。

注意,迭代器的快速失败行为不能得到保证,一般来说,存在不同步的并发修改时,不可能作出任何硬性保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此,编写依赖于此异常的程序的方式是错误的,正确做法是:迭代器的快速失败行为应该仅用于检测程序错误。

2. LinkedList的实现:

  1. private transient Entry<E> header = new Entry<E>(null, null, null);
复制代码

这个成员变量是LinkedList的关键,它在链表中没有实际数据意义,是链表的标示(通俗一点就是链表的第一个无意义的元素),而且被修饰为transient,标示着他不会被序列化。header也可以当做队列末尾的元素,因为是双向列表,所以header.next末尾元素后边的元素就成了队首元素,header.previous就是队尾元素了,看一下它的添加方法


  1. public void addFirst(E paramE) {
  2. addBefore(paramE, this.header.next);//队首
  3. }
  4. public void addLast(E paramE) {
  5. addBefore(paramE, this.header);//队尾
  6. }
复制代码

以上两个方法都利用addBefore方法将元素添加到指定对象之前,

addFirst向队头加元素,将元素paramE添加到header.next-队首元素之前;
addLast向队尾加元素,将元素paramE添加到header之前;

再看一下addBefore(E e,Entry entry)函数


  1. /***
  2. * 要添加的元素:paramE
  3. * 目标对象:paramEntry
  4. */
  5. private Entry<E> addBefore(E paramE, Entry<E> paramEntry)
  6. {
  7. //要添加的对象
  8. Entry localEntry = new Entry(paramE, paramEntry, paramEntry.previous);
  9. /***
  10. * localEntry.previous = paramEntry.previous
  11. * 目标对象的前一元素的后一元素(localEntry.previous.next)设置为要添加的对象
  12. */
  13. localEntry.previous.next = localEntry;
  14. /***
  15. * localEntry.next = paramEntry
  16. * 目标对象的前一元素(localEntry.next.previous)设置为要添加的对象
  17. */
  18. localEntry.next.previous = localEntry;
  19. this.size += 1;
  20. this.modCount += 1;
  21. return localEntry;
  22. }
复制代码

链表的基本特性是插入速度快,遍历速度慢,下面两个方法可以反映这个特点


  1. public int indexOf(Object paramObject) {
  2. int i = 0;
  3. Entry localEntry;
  4. /***
  5. * 遍历规则:从头到尾,序列呈升序状态
  6. */
  7. if (paramObject == null)
  8. for (localEntry = this.header.next; localEntry != this.header; localEntry = localEntry.next) {
  9. if (localEntry.element == null)
  10. return i;
  11. i++;
  12. }
  13. else {
  14. for (localEntry = this.header.next; localEntry != this.header; localEntry = localEntry.next) {
  15. if (paramObject.equals(localEntry.element))
  16. return i;
  17. i++;
  18. }
  19. }
  20. return -1;
  21. }
  22. public int lastIndexOf(Object paramObject) {
  23. int i = this.size;
  24. Entry localEntry;
  25. /***
  26. * 遍历规则:从尾到头,序列呈降序状态
  27. */
  28. if (paramObject == null) {
  29. for (localEntry = this.header.previous; localEntry != this.header; localEntry = localEntry.previous) {
  30. i--;
  31. if (localEntry.element == null)
  32. return i;
  33. }
  34. }else {
  35. for (localEntry = this.header.previous; localEntry != this.header; localEntry = localEntry.previous) {
  36. i--;
  37. if (paramObject.equals(localEntry.element))
  38. return i;
  39. }
  40. }
  41. return -1;
  42. }
复制代码
值得注意的是,链表插入数据速度快的说法是相对的,在数据量很小的时候,ArrayList的插入速度不仅不比LinkedList慢,而且还快很多(本文不作介绍,读者可自行测试),只有当数据量达到一定量,这个特性才会体现出来,这需要开发者明确需求场景
LinkedList的方法entry(int index)类似ArrayList的get(int index)


  1. /***
  2. * 根据序号获取Entry对象
  3. */
  4. private Entry<E> entry(int paramInt) {
  5. if ((paramInt < 0) || (paramInt >= this.size)) {
  6. throw new IndexOutOfBoundsException("Index: " + paramInt + ", Size: " + this.size);
  7. }
  8. Entry localEntry = this.header;
  9. int i;
  10. /***
  11. * 二分法:目标序号小于Size的1/2,则从头到尾
  12. * 如果大于Size的1/2,则从尾到头
  13. */
  14. if (paramInt < this.size >> 1) {
  15. for (i = 0; i <= paramInt; i++)
  16. localEntry = localEntry.next;
  17. } else {
  18. for (i = this.size; i > paramInt; i--)
  19. localEntry = localEntry.previous;
  20. }
  21. return localEntry;
  22. }
复制代码

LinkedList还提供了降序迭代器,如下


  1. public Iterator<E> descendingIterator() {
  2. return new DescendingIterator(null);
  3. }
复制代码

关于降序迭代的具体实现可以看看源码,很简单
LinkedList是针对链表操作的一个比较全的实现,对于频繁的数据插入有较高效率,研究其具体实现可更有利于准确的使用它。该类的toArray、clone以及其他一些方法很值得参考。

3. LinkedList.Entry
LinkedList的内部类Entry是实现Deque接口的基本操作单元,其结构如下:


  1. private static class Entry<E>
  2. {
  3. E element;
  4. Entry<E> next;
  5. Entry<E> previous;
  6. /***
  7. * 构造方法:目标对象paramE将被放置在paramEntry1之前,paramEntry2之后
  8. */
  9. Entry(E paramE, Entry<E> paramEntry1, Entry<E> paramEntry2)
  10. {
  11. this.element = paramE;
  12. this.next = paramEntry1;
  13. this.previous = paramEntry2;
  14. }
  15. }
复制代码

4. 内部迭代器:ListItr

虽然上层父类AbstractList已经实现了迭代器,但LinkedList的直接父类AbstractSequentialList给子类重新定义个一个需要实现的迭代器的抽象方法,代码如下:


  1. public abstract class AbstractSequentialList<E> extends AbstractList<E> {
  2. /***
  3. * 返回子类实现的迭代器
  4. */
  5. public Iterator<E> iterator() {
  6. return listIterator();
  7. }
  8. public abstract ListIterator<E> listIterator(int paramInt);
  9. }
复制代码

此处实现的迭代器内部机制跟AbstractList基本一致,可以看看源码
此类的迭代器的实现机制可以通过ListItr的remove方法来分析,同时也可分析Java对双端队列的处理办法


  1. /***
  2. * 当前指针位置:this.next
  3. * 当前所操作的对象:this.lastReturned
  4. */
  5. public void remove() {
  6. checkForComodification();
  7. LinkedList.Entry localEntry = this.lastReturned.next;
  8. try {
  9. LinkedList.this.remove(this.lastReturned);
  10. } catch (NoSuchElementException localNoSuchElementException) {
  11. throw new IllegalStateException();
  12. }
  13. /***
  14. * 当链表的size为0,指针会指向this.header,其他方法(如set方法)将以此判断当前操作对象的状态
  15. */
  16. if (this.next == this.lastReturned)
  17. this.next = localEntry;
  18. else
  19. this.nextIndex -= 1;
  20. /***
  21. * 调用LinkedList.this.remove(E)之后
  22. * 当前操作对象this.lastReturned指向的对象被设置为this.header(原对象为null)
  23. * 指针移动到this.lastReturned.next
  24. */
  25. this.lastReturned = LinkedList.this.header;
  26. //修改次数加1
  27. this.expectedModCount += 1;
  28. }
复制代码







回复

使用道具 举报