LinkedList删除效率一定就比ArrayList快？不一定！！

引入

先上代码：

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)，找到相应的元素后，还需要把这个元素从链表中删除，只需要把指向待删除元素的指针后移和前移就可以了。

总结

1. ArrayList根据索引的删除：
   定位元素快，O(1)，但是去除相应元素较慢，需要移动元素位置进行复制
2. LinkedList根据索引的删除：
   定位元素慢，O(n)，但是去除相应的元素较快，只需要移动相应的指针， 不需要移动元素位置
3. 结合以上的结论，可以看出两者根据索引删除元素的效率是差不多的，当索引取到一定的值时（例如本例取集合长度的中间值），可以看出ArrayList删除元素的效率反而比LinkedList要高。

（鉴于博主的能力和时间，以上所述可能存在不妥的地方，请读者不吝指教，可在评论区中提出，感谢！）