ArrayList 和 LinkedList 源码分析

List 表示的就是线性表,是具有相同特性的数据元素的有限序列。它主要有两种存储结构,顺序存储和链式存储,分别对应着 ArrayList 和 LinkedList 的实现,接下来以 jdk7 代码为例,对这两种实现的核心源码进行分析。

1. ArrayList 源码分析

ArrayList 是基于数组实现的可变大小的集合,底层是一个 Object[] 数组,可存储包括 null 在内的所?#24615;?#32032;,默认容量为 10。元素的新增和删除,本?#31034;?#26159;数组元素的移动。

1.1 add 操作

ArrayList 内部有一个 size 成员变量,记录集合内元素总数,add 操作的本?#31034;?#26159; elementData[size++] = e,为了保证插入成功,会按需对数组进行扩容,扩容代码如下:

private void grow(int minCapacity) {
  // 有可能会溢出
  int oldCapacity = elementData.length;
  // 相当于 oldCapacity+(oldCapacity/2),扩大 1.5 倍
  int newCapacity = oldCapacity + (oldCapacity >> 1);
  // 确保新容量不小于 minCapacity
  if (newCapacity - minCapacity < 0)
    newCapacity = minCapacity;
  if (newCapacity - MAX_ARRAY_SIZE > 0)
    // 检查扩充的最小容量是否溢出,如果溢出值会小于 0
    newCapacity = hugeCapacity(minCapacity);
  // 生成一个新数组,旧数组没有被引用会被垃圾回收
  elementData = Arrays.copyOf(elementData, newCapacity);
}

add 操作还有一个指定位置的插入,来看具体实现(本文首发于微信公众号:顿悟源码,qq交流群:673986158):

public void add(int index, E element) {
  // 检查下标是否有效
  // 可能会抛出 IndexOutOfBoundsException 异常
  rangeCheckForAdd(index);
  // 确保足够的容量插入成功
  ensureCapacityInternal(size + 1);  // Increments modCount!!
  // 把从 index 位置开始的所?#24615;?#32032;后移一位
  System.arraycopy(elementData, index, elementData, index + 1,
                   size - index);
  // 插入新元素                   
  elementData[index] = element;
  size++; // 总数加 1
}

1.2 remove 操作

remove 分为两种,按下标删除和按元素删除。按元素首先会遍历找到匹配元素的位置下标,然后按下标进行删除:

public E remove(int index) {
  // 检查下标位置是否有效
  rangeCheck(index);
  // 更新列表结构的修改次数
  modCount++;
  E oldValue = elementData(index);
  int numMoved = size - index - 1;
  if (numMoved > 0)
      // 将 index 后的所?#24615;?#32032;前移一位
      System.arraycopy(elementData, index+1, elementData, index,
                       numMoved);
  // ?#22836;?#24341;用                      
  elementData[--size] = null; // clear to let GC do its work
  return oldValue;
}

1.3 遍历

常见的遍历代码如下:

for (int i=0; i<list.size(); i++) {
  list.get(i); // do something
}

这种遍历方式的缺点是,在遍历过程中如果修改集合结构(比如调用 remove 或 add),没有任何异常,可能会导致意想不到的输出,另外一种遍历方式,比如:

for (T obj:list) {
  // do something
}

遍历的过程中,如果使用不正当的删除操作(比如list.remove)就会抛出 ConcurrentModificationException,因为它默认使用的 Iterator 遍历方式。

Iterator 是 jdk 为所有集合遍历而设计,并且是 fail-fast 快速失败的。在 iterator 遍历过程中,如果 List 结构不是通过迭代器本身的 add/remove 方法而改变,那么就会抛出 ConcurrentModificationException。注意,在不同步修改的情况下,它不能保证会发生,它只是尽力检测并发修改的错误。

fail-fast 是通过一个 modCount 字段来实现的,这个字段记录了列表结构的修改次数,当调用 iterator() 返回迭代器?#20445;?#20250;缓存 modCount 当前的值,如果这个值发生了不期望的变化,那么就会在 next, remove 操作?#20449;?#20986;异常,核心代码如下:

private class Itr implements Iterator<E> {
  int cursor; // 下一个要返回的元素下标,初始为 0
  // 最后一个返回的元素下标,-1 表示没?#24615;?#32032;
  int lastRet = -1;
  // 缓存 modCount 的值
  int expectedModCount = modCount;
  // 是否还?#24615;?#32032;可读
  public boolean hasNext() {
    return cursor != size;
  }
  public E next() {
    // 检查 modCount 值是否变化
    checkForComodification();
    int i = cursor; // 元素下标
    if (i >= size)
        throw new NoSuchElementException();
    Object[] elementData = ArrayList.this.elementData;
    if (i >= elementData.length)
        throw new ConcurrentModificationException();
    cursor = i + 1;
    return (E) elementData[lastRet = i];
  }
  // 调用 iterator 自身的 remove 
  public void remove() {
    if (lastRet < 0)
      throw new IllegalStateException();
    checkForComodification();

    try {
      // 删除元素,此时 modCount 值改变
      ArrayList.this.remove(lastRet);
      // 移除会把lastRet后面的元素前移一位
      cursor = lastRet; // 所以还是从 lastRet 开始读
      lastRet = -1;
      // 重置 modCount 期望值
      expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
      throw new ConcurrentModificationException();
    }
  }
  final void checkForComodification() {
    // 如果变化,检测到并发修改,抛出异常
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
  }
}

2. LinkedList 源码分析

LinkedList 底层是一个双向链表,它不仅实现了 List 接口,还实现了 Deque 接口,所以既可?#22253;?#23427;当作一般线性表,?#37096;?#24403;作受限线性表主要是栈和队列

双向链表的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点,LinkedList 中的节点定义如下:

private static class Node<E> {
  E item;// 数据
  Node<E> next; // 后继节点
  Node<E> prev; // 前驱节点
  Node(Node<E> prev, E element, Node<E> next) {
      this.item = element;
      this.next = next;
      this.prev = prev;
  }
}

它包含三个成员变量:

  • int size = 0: 结点总数
  • Node first: 头结点
  • Node last: 尾结点

2.1 头插法和尾插法

链表插入时有两种插入方法,头插法尾插法,关键操作就是正确的断链和续链。头插法的代码如下:

private void linkFirst(E e) {
  // 使用临时变量指向头节点
  final Node<E> f = first;
  // 新节点前驱为 null,后继为 first
  final Node<E> newNode = new Node<>(null, e, f);
  first = newNode;
  if (f == null) // 链表为空,同时为最后一个节点
      last = newNode;
  else // 否则作为前驱节点
      f.prev = newNode;
  size++;
  modCount++;
}

头插法的结果是逆序的,尾插法的结果是顺序的。尾插法的操作也比较简单,直?#26377;?#25913; last 引用即可:

void linkLast(E e) {
  // 使用临时变量指向?#27493;?#28857;
  final Node<E> l = last;
  // 新节点前驱为 last,后继为 null
  final Node<E> newNode = new Node<>(l, e, null);
  // 重置 last 指向节点
  last = newNode;
  if (l == null)// 链表为空
      first = newNode; // 第一个节点
  else // 否则作为前一个的后继
      l.next = newNode;
  size++; // 更新列表总数和结构修改次数
  modCount++;
}

头插和尾插都只修改了一个引用,比较复杂的是在中间某个位置插入,其原理和代码如下:

链表插入

// 在非null节点succ之前插入元素e
void linkBefore(E e, Node<E> succ) {
  // assert succ != null; 以下代码顺序不能变
  // 记住 succ 的前驱节点
  final Node<E> pred = succ.prev;
  // 1-2 创建一个新节点,它的前驱指向 pred,后继指向 succ
  final Node<E> newNode = new Node<>(pred, e, succ);
  // 3 succ 前驱指向新节点
  succ.prev = newNode;
  if (pred == null) // 如果是第一个节点
      first = newNode; // 让first也指向新节点
  else // 4 否则作为 pred 的后继节点
      pred.next = newNode;
  size++; // 元素总数加1
  modCount++; // 列表结构修改次数加1
}

2.2 删除节点

同样的删除也是分为从头或尾删除,头节点的删除,就是让 first 指向它的后继节点,代码如下:

private E unlinkFirst(Node<E> f) {
  // assert f == first && f != null;
  // 为了返回元素的数据
  final E element = f.item;
  // 临时变量引用头节点的后继节点
  final Node<E> next = f.next;
  // ?#22836;?#22836;节点,全部至 null
  f.item = null;
  f.next = null; // help GC
  // 重置 first 引用
  first = next;
  // 如果删除的链表是最后一个节点
  if (next == null) 
    last = null;
  else // 头节点的前驱为 null
    next.prev = null;
  size--;
  modCount++;
  return element;
}

?#27493;?#28857;的删除,一样是修改 last 引用,让它指向它的前驱节点,与头节点删除逻辑差不多,可对照理解,代码如下:

private E unlinkLast(Node<E> l) {
  // assert l == last && l != null;
  final E element = l.item;
  final Node<E> prev = l.prev;
  l.item = null;
  l.prev = null; // help GC
  last = prev;
  if (prev == null)
    first = null;
  else
    prev.next = null;
  size--;
  modCount++;
  return element;
}

如果在某个中间位置删除,就需要正确的操作了,主要是防止在断链的过程中导致整个链条断开,代码如下:

链表节点删除

E unlink(Node<E> x) {
  // assert x != null;
  final E element = x.item;
  // 待删除元素的前驱和后继节点
  final Node<E> next = x.next;
  final Node<E> prev = x.prev;
  if (prev == null) {
    // 链表为空
    first = next;
  } else {
    // 1 前驱节点的后继指向 x 的后继节点
    prev.next = next;
    x.prev = null;
  }

  if (next == null) {
    last = prev;
  } else {
    // 2 后继节点的前驱指向 x 的前驱节点
    next.prev = prev;
    x.next = null;
  }

  x.item = null;
  size--;
  modCount++;
  return element;
}

2.3 栈和队列

就是只能在栈顶操作,后进先出的受限线性表,LinkedList 提供的与栈相关的方法有:

  • push(E e): 将元素插入栈顶,也就是插到列表的头,实?#23454;?#29992;的是 linkFirst
  • pop(): 从栈顶弹出一个元素,也就是删除并返回列表的第一个元素,实?#23454;?#29992;的是 unlinkFirst
  • peek(): 查看栈顶元素,不会删除
  • peekFirst(),peekLast(): 分别是查看栈顶和栈尾元素

队列就是只能从一端插入,另一端删除的线性表,LinkedList 提供的与队列相关的方法:

  • offer(E e): 入队列,将元素插入列表尾部,实?#23454;?#29992;的是 linkLast
  • offerFirst,offerLast: 分别是从头开始或从?#37096;?#22987;入队,当然了,确认在哪端就不要更改了
  • remove(): 出队列,将列表头结点删除并返回
  • removeFirst,removeLast: 与 offerFirst,offerLast 搭配使用

2.4 遍历

双链表有两种遍历方式:顺序遍历和逆序遍历,分别通过 ListItr 和 DescendingIterator 实现。同样这个 Iterator 也是快速失败的,其中 ListItr 分别提供了向前和向后的遍历方式,DescendingIterator 只是简单对 ListItr previous() 方法使用的封装,ListItr 核心代码如下:

private class ListItr implements ListIterator<E> {
  private Node<E> lastReturned = null;// 最后返回的节点
  private Node<E> next;// 下一个要读的节点
  private int nextIndex;// 下一个要读的节点位置
  // 缓存列表结构修改次数,检查并发修改
  private int expectedModCount = modCount;
  // 初始化开始遍历的位置,node(index) 会遍历找到这个节点
  ListItr(int index) {
    // assert isPositionIndex(index);
    next = (index == size) ? null : node(index);
    nextIndex = index;
  }
  // 顺序读?#20445;?#21028;断是否还有更多的后继节点
  public boolean hasNext() {
    return nextIndex < size;
  }
  public E next() {
    checkForComodification();
    if (!hasNext())
        throw new NoSuchElementException();
    lastReturned = next;
    next = next.next; // 移动 next 指向其后继节点
    nextIndex++;
    return lastReturned.item;
  }
  // 逆序读?#20445;?#21028;断是否还有更多的前驱节点
  public boolean hasPrevious() {
    return nextIndex > 0;
  }
  public E previous() {
    checkForComodification();
    if (!hasPrevious())
        throw new NoSuchElementException();
    // 移动 next 指向其前驱节点
    lastReturned = next = (next == null) ? last : next.prev;
    nextIndex--;
    return lastReturned.item;
  }
  public void remove() {
    // 遍历过程中,提供删除操作
  }
  public void add(E e) {
    // 遍历过程中,提供新增操作 
  }
  // 检查是否存在并发修改
  final void checkForComodification() {
      if (modCount != expectedModCount)
          throw new ConcurrentModificationException();
  }
}

3. 非线程安全

ArrayList 和 LinkedList 都是非线程安全的,那为什么呢?

ArrayList 本质操作可分为以下两类,这也是线程竞争条件的所在:

  • 对 size 变量的操作,size++ 和 --size
  • System.arraycopy() 数组拷贝

size++ 其实是一个复合操作:取值、加1和赋值,不是原子操作,非线程安全;System.arraycopy 它也是非线程安全的,所以 ArrayList 不是线程安全的。

LinkedList 主要竞争条件就是断链和续链的操作,以尾插为例,假如线程 A 执行:

final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);

如果现在线程 A 被抢占,线程 B 也执行相同的代码,并且继续执行:

last = newNode;

不久后,线程 A 也执行上述代码,那?#27425;?#39064;就出来了,线程 B 完成操作后,线程 A 就操作了一次,导致线程 B 的要插入的节点丢失,所以不是线程安全的。

当然了 JDK 提供了 Collections.synchronizedList(List) 方法可?#22253;?ArrayList 和 LinkedList 变成线程安全的。

4. 性能

ArrayList 具备数组随机访问的特性,但增加和删除需要移动数组元素,效?#24335;下?#22312;动态扩容?#20445;?#28041;及到了内存拷贝,所以?#23454;?#22686;加初始容量或者在添加大量数据之前提前扩大容量,减少拷贝次数是有必要的。

相比 ArrayList,LinkedList 只能顺序或逆序访问,占用的内存稍微大点,因为节点还要维护两个前后引用,但是它的插入删除效率高。

5. 小结

这两个是很常用的数据结构,也比较容易理解,在阅读源码?#20445;琷dk里类的设计,编码方式也值得去重视。

posted @ 2019-04-24 13:34 wskwbog 阅读(...) 评论(...) 编辑 收藏
耐克篮球多少钱