ArrayList源码解读

ArrayList源码分析

相关接口抽象类介绍

  1.AbstractCollection：实现了Collection中大量的函数,除了特定的几个函数iterator()和size()之外的函数
  2.AbstractList：该接口继承于AbstractCollection，并且实现List接口的抽象类。它实现了List中除size()、get(int location)之外的函数。AbstractList的主要作用：它实现了List接口中的大部分函数 和AbstractCollection相比，AbstractList抽象类中，实现了iterator()接口
  3.List：有序队列接口,提供了一些通过下标访问元素的函数
  等等..

问题：ArrayList本质是动态数组，那么他是怎么实现动态扩容呢？

首先我们来看下ArrayList的一些基本参数

/**
   * Default initial capacity.
   */
  private static final int DEFAULT_CAPACITY = 10;

  /**
   * Shared empty array instance used for empty instances.
   */
  private static final Object[] EMPTY_ELEMENTDATA = {};

  /**
   * Shared empty array instance used for default sized empty instances. We
   * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
   * first element is added.
   */
  private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

  /**
   * The array buffer into which the elements of the ArrayList are stored.
   * The capacity of the ArrayList is the length of this array buffer. Any
   * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
   * will be expanded to DEFAULT_CAPACITY when the first element is added.
   */
  transient Object[] elementData; // non-private to simplify nested class access

  /**
   * The size of the ArrayList (the number of elements it contains).
   * ArrayList的长度
   * @serial
   */
  private int size;

初始化无参构造

/**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    elementData=null;无参构造去并不会真实的创建数组，数组会在add方法中去创建，有助于性能的提升，懒加载的方式。

初始化有参构造

/**
   * Constructs an empty list with the specified initial capacity.
   *
   * @param  initialCapacity  the initial capacity of the list
   * @throws IllegalArgumentException if the specified initial capacity
   *         is negative
   */
  public ArrayList(int initialCapacity) {
      if (initialCapacity > 0) {
          this.elementData = new Object[initialCapacity]; //创建指定长度的数组
          
      } else if (initialCapacity == 0) {
          this.elementData = EMPTY_ELEMENTDATA;
      } else {
          throw new IllegalArgumentException("Illegal Capacity: "+
                                             initialCapacity);
      }
  }

添加数据分析（下面的源码一步步看下去可以了解ArrayList动态扩容的机制）

add方法

/**  将元素添加到集合的尾部
  * Appends the specified element to the end of this list.
  *
  * @param e element to be appended to this list
  * @return <tt>true</tt> (as specified by {@link Collection#add})
  */
 public boolean add(E e) {
    //确定容量，动态扩容
     ensureCapacityInternal(size + 1);  // Increments modCount!!
     // 数组扩容后将数据添加到合适的位置  并size+1
     elementData[size++] = e;
     return true;
 }

ensureCapacityInternal方法

private void ensureCapacityInternal(int minCapacity) {
// 如果是第一次 true
 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 第一次为10
     minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
 }
 // 确保明确的容量，扩容
 ensureExplicitCapacity(minCapacity);
}

ensureExplicitCapacity 方法

private void ensureExplicitCapacity(int minCapacity) {
  modCount++; // 记录修改的次数
  // 第一次 10 - 0 > 0
  if (minCapacity - elementData.length > 0)
// 扩容
      grow(minCapacity);
}

grow:扩容的方法

private void grow(int minCapacity) {
  // 记录原来的容量
  int oldCapacity = elementData.length;
// 计算新的容量 新容量为 老容量的1.5倍 第一次为0
  int newCapacity = oldCapacity + (oldCapacity >> 1);
// 0 - 10 < 0
  if (newCapacity - minCapacity < 0)
// newCapacity = 10
      newCapacity = minCapacity;
// 10 - 10亿 > 0 false
  if (newCapacity - MAX_ARRAY_SIZE > 0)
      newCapacity = hugeCapacity(minCapacity);
  // 把原来数组中的内容拷贝到一个新建的指定容量为newCapacity的数组中，扩容
  elementData = Arrays.copyOf(elementData, newCapacity);
}