//数组拷贝
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{
// 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);
Object[] a = elementData;
// 反序列化元素并填充到数组中
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
![img](https://i-blog.csdnimg.cn/blog_migrate/cc885aa6d51aec34a824272cb9186835.jpeg)
最后
无论是哪家公司,都很重视基础,大厂更加重视技术的深度和广度,面试是一个双向选择的过程,不要抱着畏惧的心态去面试,不利于自己的发挥。同时看中的应该不止薪资,还要看你是不是真的喜欢这家公司,是不是能真的得到锻炼。
针对以上面试技术点,我在这里也做一些分享,希望能更好的帮助到大家。
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》,点击传送门即可获取!
年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!**
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
![img](https://i-blog.csdnimg.cn/blog_migrate/cc885aa6d51aec34a824272cb9186835.jpeg)
最后
无论是哪家公司,都很重视基础,大厂更加重视技术的深度和广度,面试是一个双向选择的过程,不要抱着畏惧的心态去面试,不利于自己的发挥。同时看中的应该不止薪资,还要看你是不是真的喜欢这家公司,是不是能真的得到锻炼。
针对以上面试技术点,我在这里也做一些分享,希望能更好的帮助到大家。
[外链图片转存中…(img-RRruS29u-1711961013621)]
[外链图片转存中…(img-wH2nDbxH-1711961013622)]
[外链图片转存中…(img-QueaMtCJ-1711961013622)]
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》,点击传送门即可获取!