JAVA-集合类之ArrayList类底层源码解析--创建和添加

public class Test03 {
	public static void main(String[] args) {
		Arraylist<String> list = new Arraylist<>();
		list.add("狗剩");
		for (int i = 0; i <list.size() ; i++) {
			System.out.println(list.elementData[i]);
		}
		
	}
}

我按照上面的这个例子，对ArrayList底层进行了分析，之后我将ArrayList类中的有关创建和添加的属性和方法都复制了出来，重新生成了Arraylist抽象类。

public class Arraylist<E>{
	//一维数组理论允许的最大容量
	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
	
	//无参构造默认初始化容量大小
	private static final int DEFAULT_CAPACITY = 10;
	
	//操作数
	protected transient int modCount = 0;
	
	//Object类空数组--默认
	private static final Object[] EMPTY_ELEMENTDATA = {};
	
	//默认空容量数组
	private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
	
	//ArrayList底层数据结构存储容器---Object类一维数组
	transient Object[] elementData;
	
	//ArrayList底层数据结构存储容器---一维数组的容量大小
	private int size;
	
	//无参构造函数
	public Arraylist() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    
	//有参构造函数
	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);
        }
    }
    
	//添加元素方法
	public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    
	//确保容器的大小
	private void ensureCapacityInternal(int minCapacity) {
		//调用无参构造方法创建对象，并第一次添加元素进入
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    
	//操作数+1，并判断容量是否允许添加元素
	private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
	//判断容器是否需要扩容---程序健壮性
	private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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;
    }
    //获取数组大小
	public int size() {
		// TODO Auto-generated method stub
		return size;
	}
}

首先，来说创建ArrayList对象的底层分析

第一种：无参

Arraylist<String> list = new Arraylist<>();

这一句表示new了对象，默认调用无参构造函数

public Arraylist() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

这一句是初始化，将默认容量为空的数组赋值给了我们的list

第二种：有参

Arraylist<String> list = new Arraylist<>(100);

这一句表示new了对象，调用有参构造函数

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);
        }
    }

这一句是初始化，如果给的容量大于0，则new一个initialCapacity容量大小的Object类的数组，赋值给elementData。如果容量为0，则与无参构造一样，将EMPTY_ELEMENTDATA赋值给elementData。

添加元素的ArrayList底层分析

list.add("狗剩");

比如我们现在以添加元素”狗剩“为例

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

首先底层会调用add(”狗剩“)这个方法，进入ensureCapacityInternal判断数组容量是否在规则区间中。这个时候size为0，所以minCapacity为1

private void ensureCapacityInternal(int minCapacity) {
		//调用无参构造方法创建对象，并第一次添加元素进入
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

进去先判断是否是调用无参构造方法创建对象，并第一次添加元素进入，如果是，则将DEFAULT_CAPACITY, minCapacity中的最大值给minCapacity。该例中，minCapacity为10，然后调用ensureExplicitCapacity(10);

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }     

首先modCount(操作数，是为了统一操作，防止出现异常情况，该例中，modCount不影响，因为只有添加)加一，判断minCapacity与elementData.length大小，如果minCapacity大则进如grow()方法。该例中，10>0,执行grow(10)；

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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);
    }

这是真正的ArrayList扩容机制，扩为原容量的1.5倍。该例中，oldCapacity=0,newCapacity=0，minCapacity=10，所以执行newCapacity = minCapacity语句，newCapacity=10。

elementData = Arrays.copyOf(elementData, newCapacity);则将原数组扩容为大小为10的容器。

最后将elementData[size++] = e，该例中则将elementData[0] = “狗剩”,并且返回true。

笔者也是刚开始学习这一系列集合类，会有说的不是很专业的地方，也会有犯错的地方，希望广大读者可以有错指出，我会积极改进，希望我们可以一起学好java集合类。