for (int i = 0; i < list.size(); i++) {
list.remove(i);
i–;
}
Long time3 = System.currentTimeMillis();
System.out.println(“remove----time:” + (time3 - time2));
}
结果:
add----time:4
remove----time:3
// LinkedList逆序坐标删除
public static void main(String[] args) {
List list = new LinkedList<>();
int size = 10 * 10000;
Long time1 = System.currentTimeMillis();
for (int i = 0; i < size; i++) {
list.add(i);
}
Long time2 = System.currentTimeMillis();
System.out.println(“add----time:” + (time2 - time1));
for (int i = 0; i < list.size(); i++) {
list.remove(list.size() - i - 1);
i–;
}
Long time3 = System.currentTimeMillis();
System.out.println(“remove----time:” + (time3 - time2));
}
结果:
add----time:6
remove----time:3
// LinkedList逆序对象删除
public static void main(String[] args) {
List list = new LinkedList<>();
int size = 10 * 10000;
Long time1 = System.currentTimeMillis();
for (int i = 0; i < size; i++) {
list.add(i);
}
Long time2 = System.currentTimeMillis();
System.out.println(“add----time:” + (time2 - time1));
for (int i = 0; i < list.size(); i++) {
Integer integer = list.get(list.size() - i - 1);
list.remove(integer);
i–;
}
Long time3 = System.currentTimeMillis();
System.out.println(“remove----time:” + (time3 - time2));
}
结果:
add----time:6
remove----time:12107
ArrayList因为添加触发到扩容,最终执行的是System.arraycopy本地方法,执行速度相对较快,但删除需要进行数据移动,所以执行效率低。
LinkedList正序坐标删除和逆序坐标删除,时间效率都一样,逆序坐标删除是因为程序做了特殊处理,但是如果是逆序对象删除的话,运行效率就会特别差,原理后面再介绍。
1.3、内存使用情况如何?
public static void main(String[] args) {
List list = new ArrayList<>();
int size = 100 * 10000;
for (int i = 0; i < size; i++) {
list.add(i);
}
System.out.println(“memory:”+ RamUsageEstimator.humanSizeOf(list));
}
结果:memory:19.9 MB
public static void main(String[] args) {
List list = new LinkedList<>();
int size = 100 * 10000;
for (int i = 0; i < size; i++) {
list.add(i);
}
System.out.println(“memory:”+ RamUsageEstimator.humanSizeOf(list));
}
结果:memory:38.1 MB
同等size大小的集合,显然LinkedList要比ArrayList更吃内存,所以如果是超大集合存储的话,要留意内存使用情况。
二、源码分析
2.1、ArrayList源码
2.1.1、add()
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
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);
}
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;
}
ArrayList的add()方法本质就是数组中设置值,这没什么好说的,重点在于扩容,当数组size达到扩容标准后,就会触发System.arraycopy进行数组复制,这对时间和空间上都会有一定的影响。
2.1.2、remove()
// 坐标删除
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
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
return oldValue;
}
// 对象删除
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
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
}
ArrayList的remove如果是对象删除的话也是需要循环的,删除之后还需要再执行一次System.arraycopy复制操作,所以在时间和空间上面效率都很差。如果是坐标删除的话,就不需要进行循环,直接System.arraycopy即可。
2.2、LinkedList原理
2.2.1、add()
void linkLast(E e) {
final Node l = last;
final Node newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
LinkedList的add()方法没什么可介绍的,就是链表节点的添加。
2.2.2、remove()
// 坐标删除
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
Node node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node x = last;
for (int i = size - 1; i > index; i–)
x = x.prev;
return x;
}
}
// 对象删除
public boolean remove(Object o) {
if (o == null) {
for (Node x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
![img](https://img-blog.csdnimg.cn/img_convert/d65f10266daf2985aabd3d6ed839ed28.jpeg)
分享
1、算法大厂——字节跳动面试题
2、2000页互联网Java面试题大全
3、高阶必备,算法学习
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!**
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
![img](https://img-blog.csdnimg.cn/img_convert/d65f10266daf2985aabd3d6ed839ed28.jpeg)
分享
1、算法大厂——字节跳动面试题
[外链图片转存中…(img-Pxj1OuYA-1713307733674)]
2、2000页互联网Java面试题大全
[外链图片转存中…(img-mhbsGtBb-1713307733674)]
3、高阶必备,算法学习
[外链图片转存中…(img-vUzdKkcI-1713307733674)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!