ArrayList(源码分析概述)

/*
 * ### ArrayList的使用和实现
 * List list=new ArrayList();
 * 
 * public class ArrayList<E> 
 *         extends AbstractList<E> 通过继承抽象类可以共享所有公共方法
        implements List<E>, 实现List接口 
        RandomAccess,  实现随机访问接口
        Cloneable, 实现克隆接口
        java.io.Serializable  实现序列化接口
    
        
 *  transient Object[] elementData;  真是存放数据的数组
 *  
 *  private int size; 当前集合中存储的元素个数 
 *  
 *  构造器
 *       public ArrayList() {
 *          //针对存储数据的数组进行初始化操作
            this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
            //常量定义为DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};空数组
            //如果使用无参构造器，则不会直接创建数组，而是采用空数组，当第一次添加元素时才创建数组
            //使用无参构造器时ArrayList会构建一个空数组用于未来存放数据，这里是一种对内存消耗的优化处理
        }
        
        
        带参构造器   List list=new ArrayList(18) 
            18就是初始化容积，这里的初始化参数值必须为[0,int的最大值)
        
    public ArrayList(int initialCapacity) {  //参数为初始化容积
        if (initialCapacity > 0) {  如果初始化容积大于0，则按照指定的容积创建数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;  空数组,长度为0的数组
        } else {  //初始化容积值小于0则报异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

    add方法的定义[重点]
    
    protected transient int modCount = 0;
    
    public boolean add(E e) {
        modCount++; 用于统计当前集合对象的修改次数   
        add(e, elementData, size);  参数1：新增元素；参数2：存储数据的数组；参数3：当前集合中存储的元素个数
        return true;   返回true表示添加成功
    }
    
    private void add(E e, Object[] elementData, int s) {
        //如果数组已经存满了，则首先进行扩容处理
        if (s == elementData.length)  判断当前集合中存储的元素个数是否和数组长度相等
            elementData = grow();   如果相等则进行扩容处理
        elementData[s] = e; 在数组的指定位置存储元素
        size = s + 1;  集合中所存储的元素个数
    }
    
    private Object[] grow() {  //扩容处理方法
        return grow(size + 1);  //继续调用其它扩容方法，参数为 当前存储个元素个数+1---最小容积
    }

    private Object[] grow(int minCapacity) {
         //调用Arrays工具类中的方法进行数组的拷贝,同时调用newCapacity方法计算所需要的新容积值
        return elementData = Arrays.copyOf(elementData,newCapacity(minCapacity));  
    }
    
    
    private static final int DEFAULT_CAPACITY = 10;
    
    private int newCapacity(int minCapacity) {  计算所需要的新容积值
        int oldCapacity = elementData.length;  计算原来数组的长度
        //计算新容积值
        int newCapacity = oldCapacity + (oldCapacity >> 1); 相当于是老容积增加50%，这就是扩容比
        //计算出的新容积值是否满足所需要的最小容积值
        if (newCapacity - minCapacity <= 0) {
            //如果存储数据的数组为初始化时的空数组，则计算默认初始化容积10和所需要最小容积值则最大值
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                return Math.max(DEFAULT_CAPACITY, minCapacity);
            if (minCapacity < 0) // OOM内存溢出
                throw new OutOfMemoryError();
            return minCapacity;
        }
        //如果计算出的新容积值大于所需要的最小容积值
        return (newCapacity - MAX_ARRAY_SIZE <= 0)
            ? newCapacity
            : hugeCapacity(minCapacity);
                //如果计算出的新容积值小于最大允许的容积值，则返回计算出的新容积
                     (minCapacity > MAX_ARRAY_SIZE)
                        ? Integer.MAX_VALUE
                        : MAX_ARRAY_SIZE;
           //如果计算出的新容积值大于最大允许的容积值并且minCapacity大于MAX_ARRAY_SIZE，则返回最大整数值，否则返回最大允许的容积值
    }
    
    //数组长度的上限值
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
 * 
 *  
 *  数组的拷贝操纵定义在Arrays工具类中，copyof会新建一个指定长度newLength的数组，并且将原始数组中的所有元素拷贝到新数组中，同时返回新创建的数组
 *  参数1是原始数组，参数2为所需要的新长度
    public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }
    
    
     * The maximum size of array to allocate (unless necessary).
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     * 
     * 要分配的最大数组大小（除非必要）。一些虚拟机在数组中保留一些头
     * 字。尝试分配较大的阵列可能会导致：OutOfMemoryError请求的数组大小超过VM限制
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
    由于在不同的平台上，受到平台的影响导致能够为数组分配的实际最大数值并非
    为Integer.MAX_VALUE(2,147,483,647)，而是与这个值相接近的数值。因此，
    作者减8实际上是因为不想让你创建的数组在扩容时计算的新容量值等于或过于
    接近最大值不能被平台分配出来而报出OOM错误。
 
 *结论：
 * - 如果直接初始ArrayList，则采用延迟初始化处理【初始化数组长度为0】的
 * 方式以节约内存，当添加数据时，才进行数组的初始化，默认初始化容积为10
 * - 添加数据时当存储数据的数组长度不足时，数组会自动变长，变长的比例为
 * 原容积的50%
 * 
 * 
 * 
 * 删除元素
 *  public E remove(int index) {
        Objects.checkIndex(index, size);   //检查所需要删除位置下标参数是否在合理的范围内[0,size-1]，如果超出范围则报异常
        final Object[] es = elementData;  获取所存储的所有元素数组
        E oldValue = (E) es[index];  获取指定位置上的元素
        fastRemove(es, index);   利用System.arrayCopy的方法使用覆盖的方式删除指定位置上的元素
        return oldValue;  返回删除掉的元素
        
        //没有缩容处理
    }
    
    private void fastRemove(Object[] es, int i) {
        modCount++;   修改次数+1
        final int newSize;  
        if ((newSize = size - 1) > i) //size - 1就是可以删除元素的最大下标
            System.arraycopy(es, i + 1, es, i, newSize - i); 通过数组拷贝的方式覆盖掉指定位置的元素
        es[size = newSize] = null; //最后位置赋null值
        
        {1,2,3,4,5} 执行arrayCopy方法需要覆盖下标为2的元素{1,2,4,5,5}
    }
    
    结论：
    - 使用数组元素移动的方式实现元素的删除。注意：这里没有变小容积
    - 修改元素个数时会有modCount的修改--快速失败
    
    
    get方法的实现
        public E get(int index) {
        Objects.checkIndex(index, size);针对索引下标进行合法性验证
        return elementData(index);
    }
    
    E elementData(int index) {
        return (E) elementData[index];
    }
    
    迭代器的实现类中定义【内部类】
    private void checkForComodification() {
        if (modCount != expectedModCount) { 
            throw new ConcurrentModificationException(); 并发修改异常
        }
    }
    
    结论：首先要求index应该在[0,size-1]的范围内，否则异常
          如果index正确则按照下标从数组中获取元素

            如果多个线程同时操作一个ArrayList，可以通过ConcurrentModificationException解决修改出现的线程安全问题
 */