【JavaSE8 高级编程 集合框架】集合框架入门系列②Collection&List实现类ArrayList 2019_9_1
Collection实现类ArrayList
- ArrayList
- 父类及其实现接口
- Field
- Method
- 构造器*3
- 增*4
- 删*6+1
- 改*2
- 查*8
- 转换*2
- 其他函数*4
- 补充
前言：欢迎各位评论斧正，我会一一回复，如果对本文的逻辑结构有更好的修正我会考虑并采取相应行动。
…
使用感悟：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[]数组【当然是可 [] 泛型】
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