【JavaSE8 高级编程 集合框架】集合框架入门系列②Collection&List实现类ArrayList 2019_9_1

前言：欢迎各位评论斧正，我会一一回复，如果对本文的逻辑结构有更好的修正我会考虑并采取相应行动。
…
使用感悟：Array作为基本数据结构，是基于硬件——内存的物理结构而产生的，Array与内存这一物理存在相互对应的。简单图像抽象8G内存条 ——>【口口口口口口口口】，共有8个小黑块，这8个小黑块存储8个对象Object。我们以从左向右的顺序来定义，以数字符号【0，1，2，3，4，5，6，7】映射这8个小黑块，那么，如果我们也把Array看作一个对象，那么就可以用——arr[index]来获取index索引处存储的对象Object。是不是很简单，很容易理解？这就是很底层的数据结构

【闲谈】任何事物都是从简到繁，所以也不需要觉得以前的程序员很厉害，他们当时面临的问题量级是远远没有现在的问题量级大。现在的程序员不比老一辈差，甚至更强。

底层操作起来效率高，但是麻烦，而高级操作效率低一点，但胜在方便，一个函数调用就能解决复杂问题。
这就引出了ArrayList，是基于Array实现的一个封装类，内部包裹一个Array作为本体，提供许多复杂功能函数，方便我们在解决实际问题时直接调用，而不需要再自己写几百行工具函数。但这也导致了我们不能直接访问Array本体数组，不能通过arr[index]的底层操作直接修改数组。

ArrayList

本质：本体为Object数组对象

父类及其实现接口

//AbstractCollection顶级抽象父类 向下传递的 属性
public abstract class AbstractCollection<E> implements Collection<E> {
    //数组最大长度
	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
}
//AbstractList抽象父类 向下传递的 属性
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    //修改（增删改）计数器
    protected transient int modCount = 0;
}

Field

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
	//ArrayList聚集内元素最多个数 = int最大值！！！ 2^(4*8-1)-1 = 2,147,483,647
	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
	//初始化容量=10
	private static final int DEFAULT_CAPACITY = 10;
	
	//本体——Object[]数组【当然是可 <E>[] 泛型】
	transient Object[] elementData;
	//两个空数组，只是名称不同。【作用下面详解】
	private static final Object[] EMPTY_ELEMENTDATA = {};
	private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
	//ArrayList内元素计数器
	private int size;
}

注1：EMPTY_ELEMENTDATA【EE】，DEFAULTCAPACITY_EMPTY_ELEMENTDATA【DEE】存在意义：
【EE】：优化 new ArrayList 空实例 时产生不必要的空数组对象
【DEE】：区别 EE，以了解添加第一个元素时是应该从10 膨胀，还是膨胀添加元素的个数*1.5

Method

构造器：3个ArrayList()
【无参默认空间10，初始化 int 空间，转换Collection为ArrayList】

增函数：2个add()，2个addAll()
【插中/尾加单个、Collection】

删函数：2个remove()，removeAll() / retainAll()，removeIf()，clear()
【索引/对象删，Collection内外删，断言否删，全部删】

改函数：set()，replaceAll()
【索引改，一元函数全部改】

查函数：get()，indexOf() / lastIndexOf()，isEmpty()，size()，contains()，containsAll()，subList()
【索引查对象，对象前/后向查索引，非空，元素个数，包含单个/Collection，获取子List】

转换：2个toArray()
【Object []，T []】

其他函数：sort()，clone()，ensureCapacity()，trimToSize()
【传入比较器排序，克隆并清0修改计数器，扩容int，最小化存储空间】

迭代器：iterator()，2个listIterator()
【获取普通迭代器，List增强迭代器】

流式函数：stream()，spliterator()，parallelStream()，forEach()流式消费

构造器*3

总结：空（懒加载，初始容量10），int（初始容量int），Collection（复制副本）

//无参 DEE
public ArrayList() {
    //空参指定 DEE数组对象 赋给 本体elementData【不指定初始化容量，则至少以10开始膨胀】
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//单参重载 int 0EE
public ArrayList(int initialCapacity) {
    //参数合法性判断
    if (initialCapacity > 0) {
        //本体elementData 就是Object[]数组
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        //如果new的时候传入0，则本体赋值为 EE【区别，如果指定了0，那么以后以1.2.3...膨胀的】
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
    }
}
//单参重装 Collection（List Set Queue）
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    //情况1，有且toArray返回Object[]，ArrayList本体——elementData对象 就不需要做任何操作。
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652) 注2
        //情况2，toArray返回对象不为Object[]则强转
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } 
    //情况3，空
    else {
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

注1：存在1个Object[]数组，并不代表着我们可以将Object对象存进去，因为这取决于数组中元素实际/运行时类型。
例如：Object[] arr = new String[10]; arr[0] = new Integer(1); 就会报错 java.lang.ArrayStoreException

注2：由于存储不同类型的ArrayList对象.toArray()返回值不一定为Object[]可以是String[]，方法可被重写，故需要强转。

增*4

总结：增函数分2类【插入 单个/聚集，末尾增 单个/聚集】，只有3个核心函数，其余的都是对索引相关操作。
①elementData[size++] = e;【加1个】
②Arrays.copyOf();【数组整体复制 · old数组元素到new数组并以指定class作为返回值数组类型】
③System.arraycopy();【数组内部迁移 · 本体某部分 --》本体另一位置，迁移·复制聚集c数组 --》本体某位置】

//1.末尾增加一个元素e
public boolean add(E e) {
    //判断是否需要扩容，如果扩容了会令modCount+1
    ensureCapacityInternal(size + 1);
    //末尾[size++]
    elementData[size++] = e;
    return true;
}
//ensureCapacityInternal【确定内部容量】
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//calculateCapacity【计算最小容量】
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    //情况1，如果 ArrayList 为 DEE 【new时未指定初始化容量，则最小膨胀10】
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //返回 DEFAULT_CAPACITY=10 与 1 之间最大值
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //情况2：如果非空，返回size+1
    return minCapacity;
}
//ensureExplicitCapacity【决定是否扩容容量】
private void ensureExplicitCapacity(int minCapacity) {
    //修改计数器+1
    modCount++;
    // 如果最小容量 > 原object[]长度 扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
//grow【new新数组，调用Arrays.copyOf()复制旧数组】
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    //新数组 = 1.5*旧数组(elementData.length)
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //此处针对 空参构造器未指定initialCapacity添加
    //【空参：e.len=0,minCapacity=10,newCapacity=0+0/2=0】
    //【指定0：e.len=0,minCapacity=0+1,newCapacity=1+1/2=1】
    if (newCapacity - minCapacity < 0)
        //minCapacity=Default_Capacity=10
        newCapacity = minCapacity;
    //新ArrayList过大，最大只能为 Objec[Integer.MAX_VALUE]通过hugeCapacity()
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    //最小容量通常与size很接近，是一个优势——占有内存小
    elementData = Arrays.copyOf(elementData, newCapacity);
}
//hugeCapacity【最大集合限制】
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    //最小容量 > Integer.MAX_VALUE - 8 返回 Integer.MAX_VALUE，否则返回 Integer.MAX_VALUE - 8
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
    MAX_ARRAY_SIZE;
}

//2.插入在指定索引处，原索引处对象及之后对象全部按序后移
public void add(int index, E element) {
    //检查索引合法性
    rangeCheckForAdd(index);
	//判断是否扩容，需要则new新数组扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //将原索引处对象及之后对象全部按序后移，通过System.arraycopy
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    //将index位置处元素替换为 传入参数element对象
    elementData[index] = element;
    //计数器+1
    size++;
}
//rangeCheckForAdd【索引合法性检查】
private void rangeCheckForAdd(int index) {
    //只允许末尾及末尾-起始间插入，即便是容量10，但size=1，就不能插入到[2]，只能插入末尾[1]或[0]
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

//3.末尾增加一个聚集对象（一堆）
public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    //确定是否需要扩容，如果需要以本数组size+聚集c.len扩容，扩容会令modCount+1
    ensureCapacityInternal(size + numNew);  // Increments modCount
    //调用System.arraycopy()，a[]从0开始共计numNew个 复制到 elementData[]从size处开始复制共计numNew个
    System.arraycopy(a, 0, elementData, size, numNew);
    //新聚集的size=size+numNew
    size += numNew;
    //只要聚集c的length不为0，就返回true
    return numNew != 0;
}

//4.插入一个聚集对象（一堆）
public boolean addAll(int index, Collection<? extends E> c) {
    //判断索引合法性
    rangeCheckForAdd(index);
	//获取聚集c的数组形式，及聚集c的元素个数
    Object[] a = c.toArray();
    int numNew = a.length;
    //确定是否需要扩容，如果需要以本数组size+聚集c.len扩容，扩容会令modCount+1
    ensureCapacityInternal(size + numNew);  // Increments modCount
	//计算原数组后移的元素个数
    int numMoved = size - index;
    //如果有元素要后移至聚集c插入后，调用System.arraycopy()后移
    if (numMoved > 0)
        //将elementData从index处开始共numMoved个复制到index+numNew处开始
        System.arraycopy(elementData, index, elementData, index + numNew,numMoved);
	//复制聚集c.toArray(a[])到elementData[]从index开始共numNew个
    System.arraycopy(a, 0, elementData, index, numNew);
    //计数器=原计数器+numNew
    size += numNew;
    //只要聚集c的length不为0，就返回true
    return numNew != 0;
}

注1：以DEE初始化，及以EE初始化是不同的add历程：但没有太大差别，因为只能尾部及尾部前插入
DEE：0，10【如果加入的元素个数不大于10】
EE：0，1，2，3，4，6，9，…

注2：ArrayList只能末尾及末尾-起始间插入，由 rangeCheckForAdd(index) 决定。

删*6+1

总结：删函数分为4类，删一个元素(2)、删一个聚集(2)、全删(1)、流式断言器删(1)，protected范围删除(1)
元素2：根据索引删，和根据对象删。聚集2：删除外部聚集c内的，保留外部聚集c内的。

//1.删除1个元素，根据索引
public E remove(int index) {
    //参数合法性查询【只能末尾及末尾-起始删除】
    rangeCheck(index);
	//修改器+1
    modCount++;
    E oldValue = elementData(index);
	//计算前移个数
    int numMoved = size - index - 1;
    //如果不是末尾删除，则前移 index后的全部元素 1位
    if (numMoved > 0)
        //复制elementData[]从index+1开始numMoved个，复制到index位置numMoved个
        System.arraycopy(elementData, index+1, elementData, index,numMoved);
    //末尾索引指向对象置null【由GC清理无被引用对象】
    elementData[--size] = null; // clear to let GC do its work
	//返回被删除对象oldValue【E类型的】
    return oldValue;
}
//elementData(int index)【Object元素强转为E】
E elementData(int index) {
    return (E) elementData[index];
}

//2.删除1个元素，根据对象匹配
public boolean remove(Object o) {
    //情况1，传入对象o为null
    if (o == null) {
        //删除ArrayList本体 elementData[]中的第一个null元素
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                //真正 删除工作 委托给 fastRemove()
                fastRemove(index);
                return true;
            }
    } 
    //情况2，传入对象o不为null
    else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
//fastRemove【index后全部元素前移1位，通过System.arraycopy(),原最后一位置null】
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //将本体elementData[]被抛弃元素索引处 置null
    elementData[--size] = null; // clear to let GC do its work
}

//3.取两聚集的差
public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}
//requireNonNull【非空判断】
public static <T> T requireNonNull(T obj) {
    if (obj == null)
        throw new NullPointerException();
    return obj;
}
//batchRemove【false保留非包含在传入聚集c内本体元素 / true保留包含在传入聚集c中的本体元素】
private boolean batchRemove(Collection<?> c, boolean complement) {
    //复制 本体[] 至 函数局部变量elementData[]
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    //是否有修改_return
    boolean modified = false;
    try {
        //对本体[]的复制体[]内 元素进行分类
        for (; r < size; r++)
            //根据complement标志决定删除目标：
            //1.false=不在c聚集中的元素会按照顺序 从0覆盖 elementData[]元素
            //2.true=在c聚集中的元素会按照顺序，从0覆盖 elementData[]元素
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        //保持与AbstractCollection的行为的兼容性，即使c.contains()抛出异常也要执行完下列操作
        //异常：如果c.contains()抛出异常提前终止，则将中断索引 r 处及其之后元素复制到已通过筛选的元素后
        if (r != size) {
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        //筛选后的元素个数减少，则将最后一个留存元素所处位置之后置null
        if (w != size) {
            // clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            //修改标志 = true，false代表未筛选删除任何元素
            modified = true;
        }
    }
    return modified;
}

//4.删除根据断言为false的元素（函数式接口）
public boolean removeIf(Predicate<? super E> filter) {
    	//参数非空判断
        Objects.requireNonNull(filter);
    	//被删除元素计数器
        int removeCount = 0;
    	//位计数器，只计数0，1——某个整数有没有出现过
        final BitSet removeSet = new BitSet(size);
    	//设置多线程修改检查 protected transient int modCount
        final int expectedModCount = modCount;
    	//固定当前ArrayList对象≈本体element[]内元素个数
        final int size = this.size;
    
    	//无多线程修改的情况下
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            @SuppressWarnings("unchecked")
            final E element = (E) elementData[i];
            //符合断言要求的索引被记录在BitSet对象中，等待后续保存
            if (filter.test(element)) {
                removeSet.set(i);
                removeCount++;
            }
        }
    	//检测到被多线程修改，直接抛出异常，不再向下执行
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }

        //如果有被删除的元素，则进行其后面元素的前移操作
        final boolean anyToRemove = removeCount > 0;
        if (anyToRemove) {
            final int newSize = size - removeCount;
            //i值不能超过原总个数，j值不能超过保留下的元素个数
            for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
                //i代表被保留下的元素索引，由BitSet跳跃赋值
                i = removeSet.nextClearBit(i);
                //j代表被覆盖数组的下一个被覆盖元素索引
                elementData[j] = elementData[i];
            }
            //将本体elementData[]被抛弃元素索引处 置null
            for (int k=newSize; k < size; k++) {
                elementData[k] = null;  // Let gc do its work
            }
            //更新类实例变量size为 新数组大小
            this.size = newSize;
            //如果此时检测到多线程修改，直接抛出异常，不向下继续执行
            if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
            //修改计数器+1
            modCount++;
        }
		//返回 删除标识符
        return anyToRemove;
    }

//5.删除本体中非聚集c中的元素
public boolean retainAll(Collection<?> c) {
    //非空判断
    Objects.requireNonNull(c);
    //【true保留包含在传入聚集c中的本体元素】
    return batchRemove(c, true);
}

//6.清除全部引用
public void clear() {
    //修改计数器+1
    modCount++;
    //将本体element[]所有的元素置null
    for (int i = 0; i < size; i++)
        elementData[i] = null;
    //计数器归0
    size = 0;
}

//6+1.范围删除
protected void removeRange(int fromIndex, int toIndex) {
    modCount++;
    int numMoved = size - toIndex;
    //将本体elementData从toIndex位置开始复制总共numMoved个 到 本体从fromIndex开始
    //将toIndex及其之后的元素，前移numMoved位，至fromIndex处
    System.arraycopy(elementData, toIndex, elementData, fromIndex,numMoved);
    
    //将本体elementData[]被抛弃元素索引处 置null
    int newSize = size - (toIndex-fromIndex);
    for (int i = newSize; i < size; i++) {
        elementData[i] = null;
    }
    size = newSize;
}

注1：BitSet 位集 是一种超级小巧的计数器，只计数0 & 1，表示某个整数有没有出现过。可参考cloudCoder博文

改*2

总结；改函数只有2种，改单个元素，和 改整个聚集元素。核心语句只是 数组某位置赋值罢了element[y]=x;

//1.替换1个元素
public E set(int index, E element) {
    //索引检查
    rangeCheck(index);
	//1.先取出旧元素保存
    E oldValue = elementData(index);
    //2.用新元素替换旧元素
    elementData[index] = element;
    //3.返回旧元素
    return oldValue;
}
//rangeCheck【索引检查】
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

//2.替换整个聚集的元素【流式操作】
public void replaceAll(UnaryOperator<E> operator) {
    //一元运算器对象 非空检测
    Objects.requireNonNull(operator);
    //固定当前修改器次数，为检测多线程操作
    final int expectedModCount = modCount;
    final int size = this.size;
    //对整个聚集进行for循环遍历修改
    for (int i=0; modCount == expectedModCount && i < size; i++) {
        elementData[i] = operator.apply((E) elementData[i]);
    }
    //如果没有多线程修改本聚集，则完成替换全部聚集的操作
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
    modCount++;
}

查*8

总结：查元素，索引(2)，包含(2)，非空，元素个数，取子List

//1.根据索引，查找元素
public E get(int index) {
    //索引合法性判断
    rangeCheck(index);
    return elementData(index);
}

//2.根据元素，查找前向后第一次出现的位置索引
public int indexOf(Object o) {
    //情况1：如果传入null对象，查询第一个null所在位置
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } 
    //情况2：如果传入非null对象，查询该对象第一次出现的位置
    else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    //情况3：没找到
    return -1;
}

//3.根据元素，查找后向前第一次出现的位置索引【同上，反过来】
public int lastIndexOf(Object o) {
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = size-1; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

//4.获取子List
public List<E> subList(int fromIndex, int toIndex) {
    //参数合法性检测
    subListRangeCheck(fromIndex, toIndex, size);
    //内部私有子类 继承AbstractList父类 实现 RandomAccess接口 
    //1018-1247行，本文省略
    return new SubList(this, 0, fromIndex, toIndex);
}
//subListRangeCheck【参数合法性检测】
static void subListRangeCheck(int fromIndex, int toIndex, int size) {
    if (fromIndex < 0)
        throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
    if (toIndex > size)
        throw new IndexOutOfBoundsException("toIndex = " + toIndex);
    if (fromIndex > toIndex)
        throw new IllegalArgumentException("fromIndex(" + fromIndex +
                                           ") > toIndex(" + toIndex + ")");
}

//5.查询ArrayList本体element[]的元素计数器size是否为0
public boolean isEmpty() {
    return size() == 0;
}
//6.查询元素个数
public int size() {
    return size;
}

//7.查询是否包含元素
public boolean contains(Object o) {
    return indexOf(o) >= 0;
}
//8.查询本体 是否包含 外部聚集c
public boolean containsAll(Collection<?> c) {
    for (Object e : c)
        if (!contains(e))
            return false;
    return true;
}

转换*2

总结：2个toArray()，空参返回Object[]。传入参数最好先获取本聚集元素个数，new T[arr.size()]这样只创建一次对象，如果不知道聚集元素个数，那就只创建一个new T[0]即可。

//转换：本质就是复制 私有本体element[]--> 外界新数组[]【调用Arrays.copyOf()两参、三参重载】
//1.原始类型转换数组——Object类型数组
//ArrayList -> Object[]
public Object[] toArray() {
    //就是把本体elementData[] 调用Arrays.copyOf()按照元素个数复制出去
    return Arrays.copyOf(elementData, size);
}
//2.指定类型转换数组——T[] a 数组（new int[0]即可）
//2.ArrayList -> T[]
public <T> T[] toArray(T[] a) {
    //如果传入的a数组长度不够长
    if (a.length < size)
        //直接返回new的新数组，不要a——也就是传入的a[]无所谓【当你不知道聚集元素个数传入int[0]即可】
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    //如果传入的a数组容量足够，返回a[]，直接调用System.arraycopy()
    System.arraycopy(elementData, 0, a, 0, size);
    //null标记，如果传入的a[]内部有元素，则在a[size]处设置为null
    if (a.length > size)
        a[size] = null;
    return a;
}
//System.arraycopy【Object --> Object ??】
//src被复制数组，dest目标数组，从src[srcPos]开始复制到dest[]从destPos处开始复制，共length个
public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);
//Arrays.copyOf【三参重载，第三参为强转类型】
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    //以 三目运算结果 作为数组T[] copy的赋值
    T[] copy = ((Object)newType == (Object)Object[].class)
        //1.如果内部元素的运行时类型为Object类型，则创建Object[]运行时类型数组
        ? (T[]) new Object[newLength]
        //2.如果内部元素的运行时类型不为Object类型，则创建newType[]运行时类型数组
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    //调用System.arraycopy()复制内部元素
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}
//Arrays.copyOf【两参重载，传入什么类型就返回什么类型】
public static <T> T[] copyOf(T[] original, int newLength) {
    //说白了，两参重载，最后都是调用的三参重载
    return (T[]) copyOf(original, newLength, original.getClass());
}

其他函数*4

//1.排序，实现自List接口
default void sort(Comparator<? super E> c) {
    //先获取强转为Object类型聚集元素的Object[]
    Object[] a = this.toArray();
    //再调用Arrays工具类sort方法(传入Object[]，比较器对象)
    Arrays.sort(a, (Comparator) c);
    //最后强转Object[]内Object类型元素为E类型
    ListIterator<E> i = this.listIterator();
    for (Object e : a) {
        i.next();
        i.set((E) e);
    }
}

//2.克隆并清零修改计数器
public Object clone() {
    try {
        //1.生成与本聚集相同类型的ArrayList<?>对象
        ArrayList<?> v = (ArrayList<?>) super.clone();
        //2.调用Arrays.copyOf() 整体带泛型复制【原始的是System.arraycopy()不带类型】
        v.elementData = Arrays.copyOf(elementData, size);
        //3.修改计数器清零
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

//3.扩容存储空间
public void ensureCapacity(int minCapacity) {
    //条件：如果当前ArrayList实例 不是 空参构造出的【空参构造的ArrayList最小膨胀为10】
    //true：minExpand = 0
    //false：是空参构造出的 minExpand = 10（DEFAULT_CAPACITY）
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        ? 0
        : DEFAULT_CAPACITY;
	//外部传入的 最小容量 > 最小膨胀 minExpand
    if (minCapacity > minExpand) {
        //检验函数——如果minCapacity>元素个数，就进行调用扩容函数grow()
        ensureExplicitCapacity(minCapacity);
    }
}
//4.最小化存储空间
public void trimToSize() {
    //修改计数器+1
    modCount++;
    //如果 确实 元素个数小于 本体element[]数组长度，进行缩容
    if (size < elementData.length) {
        elementData = (size == 0)
            //情况1：数组中空元素，直接赋值EE（预定义的空数组对象）
            ? EMPTY_ELEMENTDATA
            //情况2：元素个数不为0
            : Arrays.copyOf(elementData, size);
    }
}

注意：Arrays.copyOf()是System.arraycopy()原始版本的增强版，重载了全类型copyOf()，并重载了三参函数，第三参数为转换后的返回数组类型——强转返回数组类型。

补充

关于 ArrayList.toArray() 的 Object[] 与 非Object[]问题，以及 Arrays.asList()注意

问题来源：c.toArray might (incorrectly) not return Object[] (see 6260652)
Java bug 6260652 ：http://bugs.java.com/bugdatabase/view_bug.do?bug_id=6260652

	//父类子类
	static class SuperClass{}
    static class SubClass extends SuperClass{}
	//测试
    @Test
    public void test11(){
        //子类数组，子类元素。运行时类型为子类类型
        SubClass[] subs = {new SubClass(),new SubClass()};
        System.out.println(subs.getClass());
        //class [Lcom.inbreeze.wrap.ListTest$SubClass;
		
        //父类数组，子类元素。运行时类型为子类类型
        SuperClass[] supers = subs;
        System.out.println(supers.getClass());
        //class [Lcom.inbreeze.wrap.ListTest$SubClass;
		
        //父类数组，子类元素 添加 父类元素！！！ArrayStoreException
        supers[0] = new SuperClass();
        //java.lang.ArrayStoreException: com.inbreeze.wrap.ListTest$SuperClass
        
        Object[] objs = new Object[2];
        //此方法，会对supers数组内元素全部进行Object类型强转
        System.arraycopy(supers,0,objs,0,2);
        objs[0] = new SuperClass();
        System.out.println(objs.getClass());
        //class [Ljava.lang.Object;
    }
//test11结论：
非Object[]且内部元素非Object类型的数组装填元素，必须与数组内元素类型相同，否则添加失败。

	@Test
    public void test22()
    {
    	//注意！！！Arrays工具类内部 自己写了一个 ArrayList私有静态嵌入类
        List<String> arraysList = Arrays.asList("123");
        System.out.println(arraysList.getClass());
        //class java.util.Arrays$ArrayList

        //运行时类型为String[]
        Object[] objArray = arraysList.toArray();
        System.out.println(objArray.getClass());
        //class [Ljava.lang.String;

    	//String[]无法装填 Object元素，只能装填String元素。
    	//或者调用System.arraycopy()强转内部元素类型
        objArray[0] = new Object();
        //java.lang.ArrayStoreException: java.lang.Object
    
    	Object[] objs = new Object[1];
        System.arraycopy(objArray,0,objs,0,1);
        objs[0] = new Object();
        System.out.println(objs.getClass());
        //class [Ljava.lang.Object;
    }
//test22结论：
1.public static <T> List<T> asList(T... a) { return new ArrayList<>(a); }
asList创建的ArrayList对象，非java.util.ArrayList类，而是java.util.Arrays类的静态嵌入类
2.java对象的向父类转型——父类多态性，子类数组转换成父类数组是允许的。但子类数组不可以装入父类对象

	@Test
    public void test33()
    {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("1");
        strings.add("2");
        strings.add("3");

        Object[] objects = strings.toArray();
        objects[0] = new Object();
        System.out.println(objects.getClass());
        //class [Ljava.lang.Object;
    }
//test33结论：
在上面也详细的写了，ArrayList的toArray方法就是调用的System.arraycopy()
会对本体element[]内每一个元素强转Object，所以，添加其他类型元素，是没有任何问题的。

class Arrays.ArrayList{
	private final E[] a;
	public Object[] toArray() {
        return a.clone();
    }
}
//总结：
Arrays.asList()产生的Arrays.ArrayList对象的toArray()方法调用的是元素类型的.clone()
没有强转Object，而ArrayList.toArray()通过System.arraycopy()对内部元素进行了强转Object