ArrayList源码分析(jdk1.7)

ArrayList

ArrayList是数组实现的线性表，容量不够时会进行扩容。

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

首先 它继承了AbstractList类，实现了List，RandomAccess，Cloneable，java.io.Serializable接口.

ArrayList特点

1. 元素可以重复，可以为null。ArrayList实现了List接口。
2. 可以随机访问。实现了RandomAccess接口，这个接口是一个标志接口。
3. 可以进行对象克隆。实现了Cloneable接口。
4. 可以被序列化。实现了Serializable接口。

ArrayList核心源码分析

1.属性分析：

//序列化id
private static final long serialVersionUID = 8683452581122892189L;
//默认初始容量为10
private static final int DEFAULT_CAPACITY = 10;
//空数组对象，如果采用默认构造方式，初始化为空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//用于保存数据的数组
private transient Object[] elementData;
//当前容量
private int size; 

2.构造函数

/*
 *带初始容量的构造函数
 */
public ArrayList(int initialCapacity) {
	super();
	//如果输入初始容量小于0，抛出异常
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
    //创建一个大小为initialCapacity的数组
    this.elementData = new Object[initialCapacity];
}
/**
 *默认构造函数
  */
public ArrayList() {
	//实现了父类的构造方法
    super();
	//将数组初始化为空数组
    this.elementData = EMPTY_ELEMENTDATA;
}
/*
 *构造一个指定集合的元素的列表，按照它们由集合的迭代器返回的顺序
  */
public ArrayList(Collection<? extends E> c) {
	
    elementData = c.toArray(); 
    size = elementData.length;
    // c.tc.toArray 返回的可能不是  Object[]
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, size, Object[].class);
}

3.方法分析

1. 增加

/*
 *插入一个元素到线性表的末尾
 */
public boolean add(E e) {
	//调用ensureCapacityInternal()方法
	ensureCapacityInternal(size + 1); 
	//将元素e赋值给elementData[size] 然后size++
	elementData[size++] = e;
	return true;
}
/*
 *指定位置index插入元素e
 */
public void add(int index, E element) {
	//调用rangeCheckForAdd()方法检查范围
	rangeCheckForAdd(index);
	//同样调用这个方法
	ensureCapacityInternal(size + 1);  // Increments modCount!!
	//将原数组index之后的值包括index都向后移动一个位置
	System.arraycopy(elementData, index, elementData, index + 1,
	                size - index);
	//将元素e插入index位置。
	elementData[index] = element;
	//容量size++
	size++;
}
/*
 *检验下标是否正确
 */
private void rangeCheckForAdd(int index) {
	//下标不正确抛出异常
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/*
 *判断容量的大小
 */
private void ensureCapacityInternal(int minCapacity) {
	//判断当前容量是否是默认的空容量
   if (elementData == EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
   //调用ensureExplicitCapability方法判断插入后的容量和数组长度的大小
    ensureExplicitCapacity(minCapacity); 
}

/**
 *判断插入后的容量和数组长度的大小
 */
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    //如果当前插入后的容量比数组长度大，调用grow方法进行扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);  
}
/*
 *扩容
 */
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)
        throw new OutOfMemoryError();
    //如果数组容量超过最大数组容量，返回整型的最大值，否则返回最大数组容量
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

2. 删除

/*
 *删除线性表的指定位置的一个元素
 */
public E remove(int index) {
	//范围检查
    rangeCheck(index);
    modCount++;
    //保存删除的元素
    E oldValue = elementData(index);
	//要移动的第一个元素的下标
    int numMoved = size - index - 1;
    //如果删除的不是最后一个元素，那么numMoved大于0，将index以后的元素全部向前移动一个位置
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //将最后一个位置置为null，GC自动回收
    elementData[--size] = null; // clear to let GC do its work
	//返回删除的元素
    return oldValue;
}
/*
 *范围检测
 */
private void rangeCheck(int index) {
	//如果index比数组容量大，抛出异常
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/*
 *删除所有和o相等的第一个元素
 */
public boolean remove(Object o) {
	//空指针检验
	if (o == null) {
	     for (int index = 0; index < size; index++)
	     //判断数组中有没有null
	          if (elementData[index] == null) {
	              fastRemove(index);
	              return true;
	          }
	} else {
	    for (int index = 0; index < size; index++)
	    //判断是否相等
	        if (o.equals(elementData[index])) {
	        //调用fastRemove方法删除index位置元素
	            fastRemove(index);
	            return true;
	        }
	}
	//没有这个元素，返回false
	return false;
}
/*
 * 删除最后一个元素，与remove的后半部分完全相同
 */
private void fastRemove(int index) {
    modCount++;
    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
}

3. 修改

public E set(int index, E element) {
	//范围检查，这个方法上面看过了
    rangeCheck(index);
	//oldValue保存原来的元素
    E oldValue = elementData(index);
    //将index下标处的值修改为element
    elementData[index] = element;
    //返回旧元素
    return oldValue;
}

4. 查找

public E get(int index) {
    rangeCheck(index);
	//返回index下标处的元素
    return elementData(index);
}