引入
先上代码:
public static void main(String[] args) {
//创建ArrayList集合,泛型为String
ArrayList<String> arrayList = new ArrayList<String>();
//给集合添加数据
for (int i = 0; i < 5000000; i++) {
arrayList.add(i + "ArrayList");
}
//删除之前的时间戳
long start = System.currentTimeMillis();
//开始删除
arrayList.remove(2500000);
//删除之后的时间戳
long end = System.currentTimeMillis();
//输出删除所用的时间
System.out.println("ArrayList删除的时间:" + (end - start));
//创建LinkedList集合
LinkedList<String> linkedList = new LinkedList<String>();
//给集合添加数据
for (int i = 0; i < 5000000; i++) {
linkedList.add(i + "LinkedList");
}
//删除开始的时间戳
start = System.currentTimeMillis();
//删除
linkedList.remove(2500000);
//删除之后的时间戳
end = System.currentTimeMillis();
//输出删除所用时间
System.out.println("LinkedList删除的时间:" + (end - start));
}
输出的结果如下:
ArrayList删除的时间:3
LinkedList删除的时间:46
可见LinkedList按照索引删除好像是比ArrayList要慢很多,那是为何呢?
探究
我们一起来探究一下其中的原因!
先来看看ArrayList的remove()方法的源码:
public E remove(int index) {
//检验索引是否合法
Objects.checkIndex(index, size);
//将装有数据的成员变量赋值给es这个局部变量
final Object[] es = elementData;
//直接根据传入的索引值定位到相应的元素
@SuppressWarnings("unchecked") E oldValue = (E) es[index];
//调用fastRemove()方法进行删除
fastRemove(es, index);
//将删除的值返回
return oldValue;
}
private void fastRemove(Object[] es, int i) {
//实际修改次数自增
modCount++;
//用于存放新的size的大小
final int newSize;
//新的size仍然大于要删除元素的索引
if ((newSize = size - 1) > i)
//将索引i之后的元素前移一个位置
System.arraycopy(es, i + 1, es, i, newSize - i);
//将最后的一个位置置为空
es[size = newSize] = null;
}
也就是说由于ArrayList存放元素的地址是连续的,所以它可以快速根据索引定位到相应的元素,时间复杂度为O(1),在删除元素的时候,也就是把索引以后的元素前移一个位置的时候是比较麻烦的,因为移动的元素可能会很多。
再来看下LinkedList的remove()方法的源码:
public E remove(int index) {
//检验索引index的合法性
checkElementIndex(index);
//返回删除的元素
return unlink(node(index));
}
//这个方法的作用主要是根据索引找到相应的元素
Node<E> node(int index) {
//如果索引在前半部分,从头开始向后找
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
//否则说明索引在后半部分,从后开始向前找
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
//这个方法的作用主要是把找的元素从链表中删除,最后返回要删除的元素
E unlink(Node<E> x) {
// assert x != null;
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
可见,LinkedList根据索引删除还是比较复杂的,首先需要根据索引判断是在集合的前半部分还是在后半部分(有点像一次折半查找),然后在这“半个集合”里面去遍历,时间复杂度是O(n),找到相应的元素后,还需要把这个元素从链表中删除,只需要把指向待删除元素的指针后移和前移就可以了。
总结
- ArrayList根据索引的删除:
定位元素快,O(1),但是去除相应元素较慢,需要移动元素位置进行复制 - LinkedList根据索引的删除:
定位元素慢,O(n),但是去除相应的元素较快,只需要移动相应的指针, 不需要移动元素位置 - 结合以上的结论,可以看出两者根据索引删除元素的效率是差不多的,当索引取到一定的值时(例如本例取集合长度的中间值),可以看出ArrayList删除元素的效率反而比LinkedList要高。
(鉴于博主的能力和时间,以上所述可能存在不妥的地方,请读者不吝指教,可在评论区中提出,感谢!)