java中ArrayList的源码实现

java中的ArrayList底层是通过数组实现的，下面是我对ArrayList源码阅读之后整理并添加了注释之后的整理，为了方便，就只贴出ArrayList的add方法以及它的一些思想还有边界条件处理：

public class ArrayList<E> implements List<E>  {    private Object[] elementData;//存储数据的数组    private int size;//数组的当前个数 而不是最大个数    private static final int DEFAULT_CAPACITY = 10;    private static final Object[] EMPTY_ELEMENTDATA = {};    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};    //为什么最大是2^31-8？ As the Array itself needs 8 bytes to stores the size 2147483648(原文)    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE-8;    private boolean RangeCheck(int index){        return (index>-1)&&(index<size);    }    //保证newSize不会越界 将集合的capacity增加到minCapacity minCapacity为所需最小容量    //采用的思路和jdk中源码思路类似 如果不足则添加原来容量的一半 用移位来实现    public void ensureCapacity(int minCapacity) {        //如果elementData为空 最小扩展到10 如果不为空 最小扩展到0        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)?0:DEFAULT_CAPACITY;        if(minCapacity>minExpand){            ensureExplicitCapacity(minCapacity);        }    }    private void ensureCapacityInternal(int minCapacity){        if(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA){            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);        }        ensureExplicitCapacity(minCapacity);    }    //确保明确的容器    private void ensureExplicitCapacity(int minCapacity){        //如果空间不足 进行扩充        if(minCapacity - elementData.length > 0){            grow(minCapacity);        }    }    //扩充容器    private void grow(int minCapacity){        int oldCapacity = elementData.length;        //扩充1.5倍 原来的数加上原来的数右移一位        int newCapacity = oldCapacity + (oldCapacity>>1);//为什么用右移而不是除以2？因为右移比除以二快        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){        if(minCapacity < 0){            throw new OutOfMemoryError();        }        //如果1.5倍超出了MAX_ARRAY_SIZE则传入Integer.MAX_VALUE否则传入MAX_ARRAY_SIZE        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;    }        public ArrayList(int initialSize){//带初始化容量大小的构造函数        super();        if(initialSize>0){//大于0直接创建            this.elementData = new Object[initialSize];            //原版jdk没有修改size 为什么不修改size?        }        else if(initialSize == 0){//等于0 直接赋空值            this.elementData = EMPTY_ELEMENTDATA;        }        else{//小于0直接抛出异常            throw new IllegalArgumentException("非法参数:"+initialSize);        }    }    public ArrayList() throws Exception{        this(DEFAULT_CAPACITY);//调用有参构造函数 默认大小为10    }    public ArrayList(Collection<? extends E> c){        elementData = c.toArray();//返回Object[]        size = elementData.length;                if(elementData.getClass() != Object[].class){//如果类型不同 则统一类型            elementData = Arrays.copyOf(elementData, size, Object[].class);//ArrayList的底层实现 数组 Arrays.copyOf() 赋值指定数组        }    }@Override    public boolean add(E e) {       ensureCapacityInternal(size+1);//确保容器空间没问题       elementData[size++]=e;       return true;    }}

在阅读jdk中ArrayList的相关源码实现后的一些感悟：

1、jdk中对边界条件的处理（对边界情况的处理很全面，但是源代码中可生成ArrayList的尺寸的上限为Integer.MAX_VALUE，然而其实达到不了那么大，最大只能是：Integer.MAX_SIZE-8，因为这个ArrayList对应的底层数组本身需要8byte来进行储存）

2、每当ArrayList需要add，但是容量又不够的时候就需要扩容，扩容之后尺寸为扩容前尺寸的1.5倍，即原来尺寸加上原来尺寸右移一位，之所以使用右移一位而不是除以2是因为右移比除以2快

3、当ArrayList的所需要的尺寸特别大的时候，如果不是事先开辟好对应的空间，而是一次一次的添加，则会在添加的过程中一次又一次地遇到需要调用ensureCapacityInternal();的情况，效率很低。所以在使用ListArray的时候最好在初始化的时候传入恰当的尺寸，或者ListArray本身提供了ensureCapacity(int minCapacity)方法，可以一次创建对应的空间，从而很好地提高效率

4、ArrayList底层实际上是通过数组实现，开辟新空间的关键在于Arrays.copyOf(elementData,size)，所以对ArrayList的查找和替换的时间复杂度为O(1)，然而插入删除的需要涉及到后面大量元素的移动，时间复杂度为O(n)

5、ArrayList的contains()、indexOf()方法以及包含调用了这些方法的containsAll()、retainAll()、removeAll()方法等底层实际上都是使用了继承自Object对象的equals()方法，所以如果想要这些方法能够正常运行，需要保证存储在ArrayList里的数据类型的equals()方法经过了重写，比较的是对象之间的值而不是对象之间的内存地址。