ArrayList的底层实现原理

ArrayList源码分析

1、java.util.ArrayList<E> : List 接口的大小可变数组的实现类

ArrayList 内部基于数组存储各个元素。
所谓大小可变数组，是指当数组容量不足以存放新的元素时，创建新数组，并将原数组中的内容复制过来。

2、ArrayList底层实现原理

构造方法源码分析

//对象数组：ArrayList的底层数据结构，transient表示该字段不进行序列化操作
transient Object[] elementData;
//实例化一个空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//实例化一个空数组
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 *指定初始容量的有参构造
 **/
public ArrayList(int initialCapacity) {
         //如果初始容量大于0就，对象数组就指向到一个新的数组，大小为所指定的大小
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            //如果大于0就指向一个空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
}
/**
* 无参构造
*/
public ArrayList() {
         //对象数组就指向到一个空数组
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

ArrayList基于数组实现，构造方法有有参构造和无参构造如果指定了初始容量且大于0就将对象数组指定到一个新的数组，大小为所指定的大小。如果调用无参构造就将对象数组指定到一个空的数组。

添加方法源码分析

//elementData中已存放的元素的个数，注意：不是elementData的容量
private int size;
//elementData的默认容量为10
private static final int DEFAULT_CAPACITY = 10;
//对象数组：ArrayList的底层数据结构，transient表示该字段不进行序列化操作
transient Object[] elementData;
//实例化一个空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//实例化一个空数组
private static final Object[] EMPTY_ELEMENTDATA = {};

protected transient int modCount = 0;

@Native public static final int   MAX_VALUE = 0x7fffffff;

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
 * 向elementData末尾中添加元素
 **/
public boolean add(E e) {
       //确保对象数组elementData有足够的容量，可以将新加入的元素e加进去
        ensureCapacityInternal(size + 1);  
        //加入新元素e，size加1
        elementData[size++] = e;
        return true;
}

// minCapacity = seize+1，即表示执行完添加操作后，数组中的元素个数 
private void ensureCapacityInternal(int minCapacity) {
        //判断是否是空数组
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //用最小容量和10进行比较，取最大值赋值给最小容量
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
 }

/**
 *确保数组的容量足够存放新加入的元素，若不够，要扩容
 **/
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        //如果数组个数minCapacity （size+1）大于数组长度就需要进行扩容
        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);
        // 根据新的容量，将数组拷贝到新的数组并赋值给数组
        elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
       // 如果数组个数小于0抛出OutOfMemoryError异常
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();       
       // 如果最数组个数大于最大容量 就返回最大值，否则返回最大容量
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
}
/**
 * 向elementData指定位置添加元素
 **/
public void add(int index, E element) {
       //指定位置检查
        rangeCheckForAdd(index);
        // 扩容检查
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //通过拷贝使数组内位置为 index 到 （size-1）的元素往后移动一位
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);         
        // 找到位置添加元素
        elementData[index] = element;
        // 元素个数加一
        size++;
}
// 判断指定位置是否超出数组个数
private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
 * @param      src      原数组.
 * @param      srcPos   原数组的起始位置.
 * @param      dest     目标数组.
 * @param      destPos  目标数组的起始位置.
 * @param      length   拷贝长度.
 **/
public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

ArrayList在无参的add方法中，每次插入新的元素时，先判断是否需要扩容，判断数组是否为空，为空则建默认的容量10赋值给minCapacity，判断是否要扩容，第一次添加，数组的size是10，之后添加元素时，在ensureExplicitCapacity方法中判断数组元素个数即size+1（形参minCapacity）是否超过数组长度，超过则需要进行扩容操作，扩容是将旧的容量扩大到1.5倍，然后将数组拷贝到新的数组完成扩容操作。最后将元素添加，并size+1。ArrayList在指定位置添加元素时，是先检查指定位置是否在数组范围内，即数组中元素个数是1，则index得小于或者低于1。然后通过拷贝使数组内位置为 index 到（size-1）的元素往后移动一位，腾出位置之后放入元素，数组个数加一。

删除方法源码分析

public E remove(int index) {
       //指定位置检查
        rangeCheck(index);
        modCount++;       
       //保留要删除的值
        E oldValue = elementData(index);
       //要移动元素个数
        int numMoved = size - index - 1;
        if (numMoved > 0)
        //通过拷贝使数组内位置为 index+1到 （size-1）的元素往前移动一位
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        //清除末尾元素让GC回收
        elementData[--size] = null; // clear to let GC do its work
        //返回删除的值
        return oldValue;
    }

删除指定位置的元素，先对index进行检查，在将要删除的值保留，计算出需要移动元素个数，再通过拷贝使数组内位置为 index+1到（size-1）的元素往前移动一位，最后将末尾元素清理让GC回收返回删除值。由于List接口继承了Collection，因此ArrayList还有一个来自Collection接口定义的删除对象boolean remove( Object o ) ，而ArrayList自定义的remove方法是T remove(int index)删除的是下标位置的对象并返回值。

参考博客链接

https://my.oschina.net/90888/blog/1625416

转载请于明显处标明出处

https://www.cnblogs.com/AmyZheng/p/9427140.html

ArrayList的底层实现原理

猜你喜欢