首先：执行
List<Person> list1 = new ArrayList<>();
在堆内存开辟了一块空间，既然是new出来的，那我们直接从构造函数入手
Object[]数组，也就是说该数组可以放任何对象（所有对象都继承自父类Object）
继续，执行
list1.add(person1)看怎么处理add的
先看
ensureCapacityInternal方法，有个参数
size，看一下这个
size从哪来的
size是int基本数据类型，成员变量初始化的为0
继续往下看
ensureCapacityInternal是在add里面调用的
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//如果底层数组就是默认的缓存数组,取两个参数的大的一个值继续往下调用,很明显这个大值为10
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//记录修改次数
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
扩容
private void grow(int minCapacity) {
// 取到旧数组的长度
int oldCapacity = elementData.length;
//计算新数组的长度
//>>是移位运算符，相当于int newCapacity = oldCapacity + (oldCapacity/2)，但性能会好一些
int newCapacity = oldCapacity + (oldCapacity >> 1);
//保证长度在正常范围内
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 用计算出来的数组长度,往下传继续处理
elementData = Arrays.copyOf(elementData, newCapacity);
}
这就是数组的扩容，一般是oldCapacity + (oldCapacity >> 1)，相当于扩容1.5倍
跟进到Arrays这个工具类，很简单
再看copyOf()方法
System.arraycopy()方法用了一个native来修饰
这是一个数组拷贝方法，大家还在写for循环拷贝数组吗？以后多用这个方法吧，简单又方便还能获得得更好的性能
顺便看一看size()方法的源码
很简单,就是返回size值,而不是底层数组的长度,就是为何String里叫length()而List里叫size()的原因
ArrayList还提供了其它构造方法，我们顺便来看一下
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
当我们在写代码过程中，如果我们大概知道元素的个数，比如一个班级大概有40-50人，我们优先考虑List<Person> list2 = new ArrayList<>(50)以指定个数的方式去构造，这样可以避免底层数组的多次拷贝，进而提高程序性能。
在长度为n数组中：
直接通过下标去访问元素，时间复杂度为O(1)
需要循环查找元素的时候，时间复杂度为O(n)
删除
删除指定位置的元素
public E remove(int index) {
rangeCheck(index);
//维护的一个变量,记录修改次数
modCount++;
//根据数组下标拿到底层数组里的元素
E oldValue = elementData(index);
//计算数组需要拷贝的元素个数
int numMoved = size - index - 1;
if (numMoved > 0)
//拷贝删除位置(index)+1后面的numMoved个元素并从删除位置(index)开始复制
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//相当于:size = size - 1; elementData[size] == null
//size减1,数组最后一个位置赋值为null
elementData[--size] = null; // clear to let GC do its work
//返回事先拿到的删除元素
return oldValue;
}
这段代码里还调了一个方法rangeCheck()方法，我们看一下
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
就是检查底层数组下标是否越界
再看另外一种删除方式
删除指定对象元素
public boolean remove(Object o) {
//如果要删除的元素为null
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
//循环查找null,找到后执行fastRemove()方法
fastRemove(index);
//删除成功,返回true
return true;
}
} else {
//要删除元素非空
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
//equals循环对比,对比成功则执行fastRemove()方法
fastRemove(index);
//删除成功,返回true
return true;
}
}
//其他情况,返回 false
return false;
}
再看一下fastRemove()方法
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
}
和上面用下标删除方式一致,就是少了某些代码，就不细说了
2 CopyOnWriteArrayList
写时复制的容器
当我们往一个容器添加元素的时候，不是直接往当前容器添加，而是
- 先将当前容器进行
copy一份,复制出一个新的容器 - 然后对新容器里面操作元素，最后将原容器的引用指向新的容器
所以CopyOnWrite容器是一种读写分离的思想
2.1 应用场景
适合高并发的读操作（读多写少）。若写的操作非常多，会频繁复制容器，从而影响性能
CopyOnWriteArrayList 写时复制的集合，在执行写操作（如：add，set，remove等）时，都会将原数组拷贝一份，然后在新数组上做修改操作。最后集合的引用指向新数组
CopyOnWriteArrayList 和Vector都是线程安全的，不同的是：前者使用ReentrantLock类，后者使用synchronized关键字。
ReentrantLock提供了更多的锁机制，在锁竞争的情况下能表现更佳的性能。就是它让JVM能更快的调度线程，才有更多的时间去执行线程。这就是为什么CopyOnWriteArrayList的性能在大并发量的情况下优于Vector的原因。
private E get(Object[] a, int index) {
return (E) a[index];
}
public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
private boolean remove(Object o, Object[] snapshot, int index) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] current = getArray();
int len = current.length;
......
Object[] newElements = new Object[len - 1];
System.arraycopy(current, 0, newElements, 0, index);
System.arraycopy(current, index + 1, newElements, index, len - index - 1);
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
