java.util.ArrayList源码解析

1.java集合框架图

2.所属包

package java.util;

3.继承与实现关系

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

4.属性

//定义了一个Object类型的数组
private transient Object[] elementData;

//定义了一个指定Object数组大小的长度
private int size;

/**
 * 数组可以分配的最大容量
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

5.构造方法

/** 构造方法1：
  * 构造一个带有初始化容量大小的空list
  * initialCapacity : 输入参数为初始化容量      
  */
public ArrayList(int initialCapacity) {
    super();
    //如果初始化容量小于0，那么就抛出一个非法参数异常。
    if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
    //初始化指定容量的Object数组
    this.elementData = new Object[initialCapacity];
}

    /**构造方法2：
     * 构造一个空的list，默认采用初始化容量为10
     */
    public ArrayList() {
        this(10);
    }

   
    //构造方法3：
    //构造一个包含指定元素的list
    public ArrayList(Collection<? extends E> c) {
	//将集合框架转化为数组
        elementData = c.toArray();
	//指定数组的长度
        size = elementData.length;
	//此处如果输入参数传过来为null时，那么就会报空指针异常
        if (elementData.getClass() != Object[].class)
	    //将c中的元素拷贝到elementData中
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

6.方法

add添加、插入方法：

/**
     * 在list的尾部添加元素
     */
    public boolean add(E e) {
		//如果容量不够，就进行扩容，扩容到size+1
        ensureCapacityInternal(size + 1);  
		//类似于数据结构中的顺序表，在Object数组的尾部添加元素
        elementData[size++] = e;
        return true;
    }

ensureCapacity对外扩容的方法：

/**
     * 增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。 
     */
    public void ensureCapacity(int minCapacity) {
        if (minCapacity > 0)
            ensureCapacityInternal(minCapacity);
    }

private void ensureCapacityInternal(int minCapacity) {
        modCount++;
        //如果扩容的容量大于当前Object数组的长度，那么就进行扩容操作
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

grow扩容容量方法：

 /**
     * 增加容量确保可以容纳下当前最少的元素参数
     */
    private void grow(int minCapacity) {
        //获取到原数组的长度
        int oldCapacity = elementData.length;
		//将原长度转换为二进制右移一位，新容量相当于扩充为原来的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
		//如果新容量比最小容量（也就是当前所需的容量的最低标准）大，那么就将最小容量作为新容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
		//如果新容量比最大容量还大，那么就使用最大容量
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

trimToSize最小化实例存储容量：

/**
     * 将此 ArrayList 实例的容量调整为列表的当前大小。应用程序可以使用此操作来最小化 ArrayList 实例的存储量。
     */
    public void trimToSize() {
        modCount++;
        int oldCapacity = elementData.length;
		//如果当前list的size比Object数组小，说明存在空的位置，那么就将空位置去掉。
        if (size < oldCapacity) {
            elementData = Arrays.copyOf(elementData, size);
        }
    }

----------------------------------该源码为jdk1.7版本的