一、ArrayList
ArrayList继承了AbstractList分别实现了List、RandomAccess(随机访问)、Cloneable(可被克隆(复制的意思))、
Serializable(可序列化)
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
1.1、RandomAccess(随机访问)
该接口是List实现来指示它们支持快速(通常是固定时间)随机访问。主这个接口的目的是允许通用算法改变它们行为提供良好的性能时，适用于随机或顺序访问列表。
操作随机访问列表的最佳算法
(如 ArrayList)，
应用于可产生二次行为顺序访问列表(如LinkedList)。
通用的列表建议使用算法检查给定列表是否为
instanceof这个接口之前，应用的算法会
如果应用于顺序访问列表，则性能较差，
并在必要时改变他们的行为，以确保他们的行为是可接受的
性能。
例子:
若是列表很大时，某些List实现提供渐进的线性访问时间，但实际上的访问时间是固定的。这样的List实现通常应该实现此接口。实际经验证明，如果是下列情况，则
List实现
对于类的典型实例，这个循环:
for (int i=0, n=list.size(); i < n; i++)
list.get(i);
运行速度比这个循环快:
for (Iterator i=list.iterator(); i.hasNext(); )
i.next();
1.2实现Cloneable接口的作用
类实现了Cloneable接口，以向Object.clone()方法表明，该方法对该类的实例进行字段对字段的复制是合法的。
没实现Cloneable接口的实例上调用Object(对象)的clone(克隆)方法将导致抛出异常CloneNotSupportedException。
按照惯例，实现此接口的类应该使用公共方法重写对象Object.clone(它是受保护的)。有关覆盖此方法的详细信息，请参阅java.lang.Object.clone()。
请注意，此接口不包含clone(克隆)方法。因此，仅凭对象实现此接口这一事实是不可能clone(克隆)对象的。即使反射性地调用clone(克隆)方法，也不能保证它会成功。
1.3实现Serializable接口的作用：
类的可序列化性是由实现java.io的类来启用的。Serializable接口。不实现此接口的类将不会对其任何状态进行序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。
2.ArrayList.class
2.1 ArrayList成员变量
/**
* 声明serialVersionUID的值，确保serialVersionUID值跨不同JAVA编译器实现的一致性（版本的兼容性）。
* 强烈建议使用Private修饰符显示声明serialVersionUID
* serialVersionUID字段作为继承成员没有用处
*/
private static final long serialVersionUID = 8683452581122892189L;
/**
* 默认初始容量。（ArrayList底层是数组结构）
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 用于空实例的共享空数组实例。(当指定数组的容量为0时使用这个常量赋值)
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 用于默认大小的空实例的共享空数组实例。我们
* 将其与EMPTY_ELEMENTDATA区分开来，以了解何时膨胀多少
* 添加第一个元素。(默认空参构造函数时使用这个常量赋值)
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 存储ArrayList元素的数组缓冲区。
* ArrayList的容量是这个数组缓冲区的长度。
* 即元素数组:真正存放数据的对象数组，transient标识不被序列化
*/
transient Object[] elementData; // 非私有以简化嵌套类访问
/**
* ArrayList的大小(它包含的元素的数量)。
*/
private int size;
/**
* 分配的数组的最大值。
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 修改次数
* /
protected transient int modCount = 0;
2.2 ArrayList构造方法
/**
*指定初始容量的大小。
*/
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {//在容量大于零的条件下，指定多大容量就是多大
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {//没有指定容量大小，则为空数组
this.elementData = EMPTY_ELEMENTDATA;//构造一个空的List其size为DEFAULT_CAPACITY = 10的空列表。
} else {//如果指定容量大小为负责，抛出异常IllegalArgumentException
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
/**
* 构造一个空的List其size为DEFAULT_CAPACITY = 10的空列表。
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 传入一个Collection初始化ArrayList
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();//把给定的集合转换成Object[]数组
if ((size = elementData.length) != 0) {//判断转换成的数组不为空
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)//判断集合存的元素不是Object
elementData = Arrays.copyOf(elementData, size, Object[].class);
//复制的数组，返回副本的长度，返回副本的类→→→新的数组[]
} else {
//elementData的length为空，直接将ArrayList的数组转为空数组
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
//将ArrayList实例的容量调整为列表的当前大小。
//应用程序可以使用此操作最小化ArrayList实例的存储。
public void trimToSize() {
modCount++;//修改次数+1
if (size < elementData.length) {
//如果底层数组的length为空则置为EMPTY_ELEMENTDATA
//否则使用Arrays的方法对复制元素
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
2.3常用方法add
2.3.1add(E a)与add(int index,E element);
//将指定的元素追加到此列表的末尾。
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;//元素添加到此列表中
return true;
}
add调用了函数→ensureCapacityInternal(int size)代码如下：
private void ensureCapacityInternal(int minCapacity) {
//若当前数组是空数组
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//则比较加入的个数与默认个数(10)比较，取较大值
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
我的理解是此函数是确认ArrayList底层数组elementData有适合的大小；
然后ensureCapacityInternal(int minCapacity)函数调用
ensureExplicitCapacity(minCapacity)代码如下：
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//修改次数+1
// overflow-conscious code(溢出)
//判断数组真实元素个数加1后的长度与当前数组长度大小关系，
//如果小于0，返回，如果大于0，则
//调用grow（minCapacity）方法
if (minCapacity - elementData.length > 0)//数组放不下
grow(minCapacity);//扩容
}
ensureExplicitCapacity(int minCapacity)此函数调用了
grow(minCapacity)函数
/**
* 增加容量，以确保它至少可以容纳由最小容量参数指定的元素数量。
*/
private void grow(int minCapacity) {
// overflow-conscious code
//老容量
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);
// minCapacity is usually close to size, so this is a win:
//扩容
elementData = Arrays.copyOf(elementData, newCapacity);
}
ArrayList动态增大主要是依赖于外汇常见问题grow(int minCapacity)方法调用
Arrays.copyOf(elementData, newCapacity);
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
总结：
add函数的调用过程
ArrayList 内部使用数组存储元素，当数组长度不够时进行扩容，每增加自身一半的空间，ArrayList不会进行缩小容容量；
ArrayList默认初始化容量为10，底层是数组结构；
线程不安全；
Key有序,value不可重复的;
ArrayList 支持随机访问，通过索引访问元素快，时间复杂度为O(1)；
ArrayList 添加元素到尾部快，平均时间复杂度为O(1)；
ArrayList 添加元素到中间比较慢，因为要搬移元素，平均时间复杂度为O(n)；
ArrayList 从尾部删除元素快，平均时间复杂度为O(1)；
ArrayList 从中间删除元素比较慢，因为要搬移元素，平均时间复杂度为O(n);
————————————————
原文链接：https://blog.csdn.net/weixin_44903953/article/details/102880906