精读分析ArrayList源码

概述

ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要进行扩容（如果不指定容量初始容量为10 ，扩容后容量为原来的1.5倍），期间会涉及已经有的数据复制到新的存储空间。所以当从ArrayList的中间位置插入或者删除元素时，需要对数据进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。线程不安全，存储元素可以为null。

源码分析

1.ArrayList#add(e)方法

   /**
     * 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!!
        // 添加元素
        elementData[size++] = e;
        return true;
    }
    /**
     *  容量检测
     */
   private void ensureCapacityInternal(int minCapacity) {
  		 // 确认ArrayList的容量，看是否需要进行扩容
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
	/**
     *   
     */
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        // 如果elementData为空，则返回默认容量(10)和minCapacity中的最大值
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        // elementData不为空，直接返回minCapacity
        return minCapacity;
    }
    // 计算容量是都需要进行扩容
	private void ensureExplicitCapacity(int minCapacity) {
			// 数组修改次数自增
	        modCount++;
	
	        // 添加新元素后需要的容量比目前数组的容量要大时则需要扩容
	        if (minCapacity - elementData.length > 0)
	        	//扩容操作
	            grow(minCapacity);
    }

    private void grow(int minCapacity) {
        // 存储数据的数组原容量
        int oldCapacity = elementData.length;
        // 扩容计算 oldCapacity + oldCapacity*2->新数组为原始数据的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 新容量小于参数指定容量，修改新容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 新容量大于最大容量(最大为 MAX_VALUE = 0x7fffffff)
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
         // 将旧数据拷贝到新数组中
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
	

这里我们要注意扩容条件：插入数据size比原来大就会进行扩容。因此我们在使用ArrayList时需要主要，避免频繁扩容（最好能够预测数据容量的大小）。

2.ArrayList#add(int index, E element)指定位置插入

 public void add(int index, E element) {
 		// 数组越界检查
        rangeCheckForAdd(index);
        // 数组容量检查-增加更改次数
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 将index之后的元素向后移动一位，将index的位置空出来
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element; // 将index的值设置为我们设定的值
        // 元素个数增加
        size++;
    }

ArrayList在指定索引位置插入元素主要流程为：数组越界检查->变更数组修改次数->插入元素。

3.ArrayList#get(int index)

  public E get(int index) {
  	 // 检查索引位置是否越界
     rangeCheck(index);
	// 返回索引对应的数据
     return elementData(index);
   }
   // 索引位置越界检查
   private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    // 查询数据
    E elementData(int index) {
        return (E) elementData[index];
    }

4.ArrayList#addAll(Collection<? extends E> c)方法元素替换：

    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        // 新添加的元素个数
        int numNew = a.length;
        // 容量担保-是否扩容
        ensureCapacityInternal(size + numNew);  // Increments modCount
        //将新添加的元素加入到集合中
        System.arraycopy(a, 0, elementData, size, numNew);
        // 更新集合size
        size += numNew;
        return numNew != 0;
    }

5.ArrayList#set(int index)方法元素替换：

public E set(int index, E element) {
	 // 检查索引位置是否越界
      rangeCheck(index);
      // 获取对应索引位置的值
       E oldValue = elementData(index);
       // 新值替换原值
       elementData[index] = element;
       return oldValue;
  }

6.ArrayList#remove(int index)

/**
  *  从指定索引位置删除元素
  */
 public E remove(int index) {
        // 检查索引位置是否越界
        rangeCheck(index);
		// 修改次数++
        modCount++;
        // 获取对应位置的数据
        E oldValue = elementData(index);
        // 判断index是否在最后一个位置
        int numMoved = size - index - 1;
        // 如果不是最后一个元素，将index之后的元素往前移动一个位置
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        // 否则删除最后一个元素--GC回收
        elementData[--size] = null; // clear to let GC do its work
        return oldValue;
    }

这边remove方法执行之后，ArrayList并没有进行缩容。

7.ArrayList#remove(Object o)

 public boolean remove(Object o) {
 		// 如果元素为null
        if (o == null) {
            // 循环遍历为null的元素，并将其移除
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    // 移除元素
                    fastRemove(index);
                    return true;
                }
        } else { // 非null
           // 循环查找对象删除
            for (int index = 0; index < size; index++)
                // equals判定对象是否为同一个对象
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }
 // 移除对应索引位置的元素
 private void fastRemove(int index) {
  	   // 这边未做越界检查---为啥remove不直接调用呢，在remove时候方法做越界检查后调用此方法不可以么？
        modCount++;
        // 判断是否是最后一个元素，这里的操作和remove(index)是一样的
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

8.ArrayList#retainAll(Collection<?> c)——交集

 // 求交集
 public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        //  求交集
        return batchRemove(c, true);
    }

    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            //遍历循环查询r中元素存在于c集合中
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    // elementData[r] 存在c集合中则添加到数组中
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            // 正常情况下r是等于size的，这里是对异常的判断
            if (r != size) {
                //将未读的元素拷贝到写指针后面
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            // 将写指针后的元素全部置空
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

9.ArrayList#removeAll(Collection<?> c)——差集

// 差集
public boolean removeAll(Collection<?> c) {
      Objects.requireNonNull(c);
      // 查询出c集合中不存在的元素
      return batchRemove(c, false);
  }

9.ArrayList#clear()清空集合元素

public void clear() {
 // 修改次数自增
     modCount++;
     // clear to let GC do its work
     for (int i = 0; i < size; i++)
         elementData[i] = null;
     size = 0;
 }

总结

• ArrayList底层数据结构为数组存储，集合的默认容量大小为10，线程不安全，可以存储null值。
• ArrayList区别于数组的地方在于可以自动扩容，扩容量为原来的1.5倍，最大支持Integer.MAX_VALUE个元素存储，但是ArrayList不会进行缩容。
• ArrayList中有求交集（retainAll）和求差集（removeAll），注意这里的差集是单向交集。
• ArrayList由于本质是数组，所以它在数据的查询方面会很快，而在插入删除这些方面，性能下降很多，因为需要移动很多数据才能达到应有的效果。