ArrayList源码阅读笔记
作者：互联网
- 在末尾添加元素
*/
public boolean add(E e) {
// 检查是否需要扩容
ensureCapacityInternal(size + 1);
// 把元素插入到末尾
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 如果是空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA，就初始化为默认大小10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
// 修改次数 +1，用于 fail-fast 处理
modCount++;
// 如果 minCapacity 大于 elementData 的长度，则进行扩容处理
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/**
- 扩容
*/
private void grow(int minCapacity) {
// 有整形溢出风险的代码
int oldCapacity = elementData.length;
//新容量=旧容量+（旧容量右移1位（除以2））,新容量为原来的1.5倍
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);
}
这里我们稍微看一下Arrays.copyOf的源码：
public static T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
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;
}
最终调用的是System.arraycopy方法，这是一个Native方法：
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
关于数组拷贝，谷歌了一下，说法不一，有说是深拷贝的，有说是浅拷贝的。暂时先放下，未来有机会再研究。
add(int index, E element)在特定位置插入元素，时间复杂度为O(n)。
public void add(int index, E element) {
// 检查是否越界
rangeCheckForAdd(index);
//检查是否需要扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
将 elementData 中位置为 index 位置及其后面的元素都向后移动一个下标（底层是 native 方法，使用 cpp 直接操作内存。）
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
// 将元素插入到index的位置
elementData[index] = element;
大小增1
size++;
}
addAll用于批量添加。
public boolean addAll(Collection<? extends E> c) {
// 集合转化成数组
Object[] a = c.toArray();
int numNew = a.length;
//检查是否需要扩容
ensureCapacityInternal(size + numNew); // Increments modCount
//将集合内的元素复制到 elementData 中，覆盖 [size, size+numNew) 的元素
System.arraycopy(a, 0, elementData, size, numNew);
//数组大小增加numNew
size += numNew;
return numNew != 0;
}
public boolean addAll(int index, Collection<? extends E> c) {
//检查下标是否越界
rangeCheckForAdd(index);
//转换为数组
Object[] a = c.toArray();
int numNew = a.length;
//检查是否需要扩容
ensureCapacityInternal(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
// 将 elementData 中位置为 index 及其以后的元素都向后移动 numNew 个位置
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
// 将集合内的元素复制到 elementData 中，覆盖 [index, index+numNew) 的元素
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
获取指定位置元素，时间复杂度为O(1)。
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
删除指定索引位置的元素，时间复杂度为O(n)。
public E remove(int index) {
//检查下标是否越界
rangeCheck(index);
modCount++;
//获取指定索引处元素
E oldValue = elementData(index);
如果index不是最后一位，则将index之后的元素往前挪一位
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//将最后一个元素删除，帮助GC
elementData[–size] = null; // clear to let GC do its work
return oldValue;
}
删除指定元素，时间复杂度为O(n²)。
public boolean remove(Object o) {
//元素为null
if (o == null) {
//遍历数组
for (int index = 0; index < size; index++)
//快速删除所有为null的元素
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
//元素不为null，遍历数组
for (int index = 0; index < size; index++)
//找到对应元素，快读删除
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
//和remove(int index)基本相同，少了检查越界的方法，无返回值
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
// 如果index不是最后一位，则将index之后的元素往前挪一位
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 将最后一个元素删除，帮助GC
elementData[–size] = null; // clear to let GC do its work
}
用于批量删除元素。
//批量删除 ArrayList 和集合 c 都存在的元素
public boolean removeAll(Collection<?> c) {
//非空校验
Objects.requireNonNull©;
//批量删除
return batchRemove(c, false);
}
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size; r++)
// 把需要保留的元素前置
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
// 跟 fastRemove(int index) 里面的操作类似，防止内存泄漏
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}
用于更改特定下标的值，时间复杂度为O(1)。
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
=====================================================================
注意观察，ArrayList 有两个属性被 transient 关键字 修饰，transient 关键字的作用：让某些被修饰的成员属性变量不被序列化
transient Object[] elementData;
protected transient int modCount = 0;
为什么最重要的元素数组要被transient 修饰呢？
因为ArrayList 并没有用Java序列化机制的默认处理来序列化 elementData 数组，而是通过 readObject、writeObject 方法自定义序列化和反序列化策略。
之所以要用自定义的序列化和反序列化策略，是因为效率的问题。如果用默认处理来序列化的话，如果 elementData 的长度有100，但是实际只用了50，其实剩余的50是可以不用序列化的，这样可以提高序列化和反序列化的效率，节省空间。
/**
- 自定义序列化
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
标签：index,return,int,ArrayList,elementData,numNew,笔记,源码,size 来源： https://blog.csdn.net/m0_66264134/article/details/122392078