ArrayList源码阅读笔记

2401_84692110

于 2024-05-16 06:24:18 发布

阅读量1k

点赞数 14

文章标签： java 面试学习

本文链接：https://blog.csdn.net/2401_84692110/article/details/138938804

版权

学习分享，共勉

这里是小编拿到的学习资源，其中包括“中高级Java开发面试高频考点题笔记300道.pdf”和“Java核心知识体系笔记.pdf”文件分享，内容丰富，囊括了JVM、锁、并发、Java反射、Spring原理、微服务、Zookeeper、数据库、数据结构等大量知识点。同时还有Java进阶学习的知识笔记脑图（内含大量学习笔记）！

资料整理不易，读者朋友可以转发分享下！

Java核心知识体系笔记.pdf

记一次蚂蚁金服Java研发岗的面试经历，分享下我的复习笔记面经

中高级Java开发面试高频考点题笔记300道.pdf

记一次蚂蚁金服Java研发岗的面试经历，分享下我的复习笔记面经

架构进阶面试专题及架构学习笔记脑图

记一次蚂蚁金服Java研发岗的面试经历，分享下我的复习笔记面经

Java架构进阶学习视频分享

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

} else {

// 如果是空集合，则初始化为空数组EMPTY_ELEMENTDATA

this.elementData = EMPTY_ELEMENTDATA;

}

add(E e)

添加元素到末尾，平均时间复杂度为O(1)。

在这里插入图片描述

/**

在末尾添加元素

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)

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

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;

}

get(int index)

获取指定位置元素，时间复杂度为O(1)。

public E get(int index) {

rangeCheck(index);

return elementData(index);

}

remove(int 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;

}

remove(Object o)

删除指定元素，时间复杂度为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

}

removeAll

用于批量删除元素。

//批量删除 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;

}

set

用于更改特定下标的值，时间复杂度为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{

// fail-fast，后续判断是否有并发处理

int expectedModCount = modCount;

// 序列化没有标记为 static、transient 的字段，包括 size 等。

s.defaultWriteObject();

s.writeInt(size);

// 序列化数组的前size个元素

for (int i=0; i<size; i++) {

s.writeObject(elementData[i]);

}

if (modCount != expectedModCount) {

throw new ConcurrentModificationException();

}

/**

自定义反序列化

private void readObject(java.io.ObjectInputStream s)

throws java.io.IOException, ClassNotFoundException {

elementData = EMPTY_ELEMENTDATA;

反序列化没有标记为 static、transient 的字段，包括 size 等

s.defaultReadObject();

s.readInt(); // ignored

if (size > 0) {

// 数组扩容

int capacity = calculateCapacity(elementData, size);

SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);

ensureCapacityInternal(size);

学习分享，共勉

资料整理不易，读者朋友可以转发分享下！

Java核心知识体系笔记.pdf

记一次蚂蚁金服Java研发岗的面试经历，分享下我的复习笔记面经

中高级Java开发面试高频考点题笔记300道.pdf

记一次蚂蚁金服Java研发岗的面试经历，分享下我的复习笔记面经

架构进阶面试专题及架构学习笔记脑图

记一次蚂蚁金服Java研发岗的面试经历，分享下我的复习笔记面经

Java架构进阶学习视频分享

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

int capacity = calculateCapacity(elementData, size);

SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);

ensureCapacityInternal(size);

学习分享，共勉

资料整理不易，读者朋友可以转发分享下！

Java核心知识体系笔记.pdf

[外链图片转存中…(img-EaviFNQu-1715811837024)]

中高级Java开发面试高频考点题笔记300道.pdf

[外链图片转存中…(img-fbTQUh7O-1715811837024)]

架构进阶面试专题及架构学习笔记脑图

[外链图片转存中…(img-cBoZ9DcT-1715811837025)]

Java架构进阶学习视频分享

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

2401_84692110

关注

14
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
ArrayList源码阅读笔记

如果用默认处理来序列化的话，如果 elementData 的长度有100，但是实际只用了50，其实剩余的50是可以不用序列化的，这样可以提高序列化和反序列化的效率，节省空间。这里是小编拿到的学习资源，其中包括“中高级Java开发面试高频考点题笔记300道.pdf”和“Java核心知识体系笔记.pdf”文件分享，内容丰富，// 将集合内的元素复制到 elementData 中，覆盖 [index, index+numNew) 的元素。关于数组拷贝，谷歌了一下，说法不一，有说是深拷贝的，有说是浅拷贝的。
复制链接

扫一扫