人物背景：
老徐，男，本名徐福贵，从事Java相关研发工作多年，职场老油条，摸鱼小能手，虽然岁数不大但长的比较着急，人称老徐。据说之前炒某币败光了所有家产，甚至现在还有欠债。
阿珍，女，本名陈家珍，刚刚入职不久的实习生，虽然是职场菜鸟但聪明好学。据说是学校的四大校花之一，追求她的人从旺角排到了铜锣湾，不过至今还单身。
老徐问道：“阿珍，你知道ArrayList和linkedList的区别吗？”
阿珍微微一笑，说：“这也太小儿科了，ArrayList是基于数组实现，linkedList是基于链表实现。”
老徐竖起了大拇指，说：“不错，有进步！那你知道ArrayList和linkedList的效率到底哪个高？”
阿珍回答：“这也难不倒我，这要分不同情况的。在新增、删除元素时，linkedList的效率要高于ArrayList，而在遍历的时候，ArrayList的效率要高于linkedList。”
老徐反问到：“不一定哦。在新增、删除元素时，linkedList的效率有可能低于ArrayList，而在遍历的时候，ArrayList的效率有可能低于linkedList。”
阿珍回答：“不可能，绝对不可能，书上都是这么写的。”
老徐得意地笑了，说：“实践是检验真理的唯一标准。趁着老板不在，咱两写个程序实践一下。”
ArrayList和linkedList的新增元素对比首先，写一段计算新增元素耗时的代码：
public static long addHeader(Listlist, int count) { long start = System.nanoTime(); for (int i = 0; i < count; i++) { list.add(0, "onemore-" + i); } long end = System.nanoTime(); return (end - start) / 1000000; } public static long addMiddle(List list, int count) { long start = System.nanoTime(); for (int i = 0; i < count; i++) { list.add(list.size() / 2, "onemore-" + i); } long end = System.nanoTime(); return (end - start) / 1000000; } public static long addTail(List list, int count) { long start = System.nanoTime(); for (int i = 0; i < count; i++) { list.add("onemore-" + i); } long end = System.nanoTime(); return (end - start) / 1000000; }
然后，我们把新增元素的个数设置为50000，对比一下：
public static void main(String[] args) {
int count = 50000;
System.out.println("从ArrayList的头部新增元素：" + addHeader(new ArrayList<>(count), count) + "ms");
System.out.println("从linkedList的头部新增元素：" + addHeader(new linkedList<>(), count) + "ms");
System.out.println("从ArrayList的中部新增元素：" + addMiddle(new ArrayList<>(count), count) + "ms");
System.out.println("从linkedList的中部新增元素：" + addMiddle(new linkedList<>(), count) + "ms");
System.out.println("从ArrayList的尾部新增元素：" + addTail(new ArrayList<>(count), count) + "ms");
System.out.println("从linkedList的尾部新增元素：" + addTail(new linkedList<>(), count) + "ms");
}
运行结果如下：
ArrayList从头部新增元素：204ms linkedList从头部新增元素：17ms ArrayList从中部新增元素：71ms linkedList从中部新增元素：8227ms ArrayList从尾部新增元素：13ms linkedList从尾部新增元素：21ms
我们可以看出，从头部新增元素时，ArrayList的效率低于linkedList；从中部新增元素时，ArrayList的效率高于linkedList；从尾部新增元素时，ArrayList的效率高于linkedList。
阿珍惊呆了，说：“怎么可能？这是为什么呀？”老徐回答：“我来帮你简单分析一下。”
ArrayList是基于数组实现的，在添加元素到数组头部的时候，在添加元素之前需要把头部以后的元素一个一个地往后挪，所以效率很低；而linkedList是基于链表实现，从头部添加元素的时候，通过头部指针就可以直接添加，所以效率很高。
ArrayList在添加元素到数组中间的时候，同样有部分元素需要一个一个地往后挪，所以效率也不是很高；而linkedList从中部添加元素的时候，是添加元素最低效率的，因为靠近中间位置，在添加元素之前需要循环查找遍历部分元素，所以效率很低。
ArrayList从尾部添加元素的时候，不需要挪动任何元素，直接把元素放入数组，效率非常高。而linkedList虽然不需要循环查找遍历元素，但linkedList中多了实列化节点对象和变换指针指向的过程，所以效率较低一些。
当然，这里有一个大前提，就是ArrayList初始化容量足够，不需要动态扩容数组容量。所以，在我们的日常开发中，最好指定ArrayList的初始化容量。
ArrayList和linkedList的删除元素对比首先，写一段计算删除元素耗时的代码：
public static double deleteHeader(Listlist, int count) { for (int i = 0; i < count; i++) { list.add("onemore-" + i); } long start = System.nanoTime(); for (int i = 0; i < count; i++) { list.remove(0); } long end = System.nanoTime(); return (end - start) / 1000000.0; } public static double deleteMiddle(List list, int count) { for (int i = 0; i < count; i++) { list.add("onemore-" + i); } long start = System.nanoTime(); for (int i = 0; i < count; i++) { list.remove(list.size() / 2); } long end = System.nanoTime(); return (end - start) / 1000000.0; } public static double deleteTail(List list, int count) { for (int i = 0; i < count; i++) { list.add("onemore-" + i); } long start = System.nanoTime(); for (int i = 0; i < count; i++) { list.remove(list.size() - 1); } long end = System.nanoTime(); return (end - start) / 1000000.0; }
然后，我们把删除元素的个数设置为50000，对比一下：
public static void main(String[] args) {
int count = 50000;
System.out.println("从ArrayList的头部删除元素：" + deleteHeader(new ArrayList<>(count), count) + "ms");
System.out.println("从linkedList的头部删除元素：" + deleteHeader(new linkedList<>(), count) + "ms");
System.out.println("从ArrayList的中部删除元素：" + deleteMiddle(new ArrayList<>(count), count) + "ms");
System.out.println("从linkedList的中部删除元素：" + deleteMiddle(new linkedList<>(), count) + "ms");
System.out.println("从ArrayList的尾部删除元素：" + deleteTail(new ArrayList<>(count), count) + "ms");
System.out.println("从linkedList的尾部删除元素：" + deleteTail(new linkedList<>(), count) + "ms");
}
运行结果如下：
从ArrayList的头部删除元素：260.7014ms 从linkedList的头部删除元素：14.2948ms 从ArrayList的中部删除元素：95.9073ms 从linkedList的中部删除元素：3602.6931ms 从ArrayList的尾部删除元素：1.6261ms 从linkedList的尾部删除元素：3.9645ms
我们可以看出，从头部删除元素时，ArrayList的效率低于linkedList；从中部删除元素时，ArrayList的效率高于linkedList；从尾部删除元素时，ArrayList的效率高于linkedList。
阿珍抢着说：“删除元素这个我知道，和新增元素的原理差不多。”老徐回答：“既然你知道了，我就不啰嗦了，我们继续看遍历元素。”
ArrayList和linkedList的遍历元素对比遍历元素一般有两种方式：for循环和foreach，写一段计算这两种遍历方式耗时的代码：
public static double getByFor(Listlist, int count) { for (int i = 0; i < count; i++) { list.add("onemore-" + i); } String name = "万猫学社"; long start = System.nanoTime(); for (int i = 0; i < count; i++) { if (name.equals(list.get(i))) { System.out.println(name); } } long end = System.nanoTime(); return (end - start) / 1000000.0; } public static double getByForeach(List list, int count) { for (int i = 0; i < count; i++) { list.add("onemore-" + i); } String name = "万猫学社"; long start = System.nanoTime(); for (String str : list) { if (name.equals(str)) { System.out.println(name); } } long end = System.nanoTime(); return (end - start) / 1000000.0; }
然后，我们把遍历元素的个数设置为50000，对比一下：
public static void main(String[] args) {
int count = 50000;
System.out.println("通过for循环遍历ArrayList：" + getByFor(new ArrayList<>(count), count) + "ms");
System.out.println("通过for循环遍历linkedList：" + getByFor(new linkedList<>(), count) + "ms");
System.out.println("通过foreach遍历ArrayList：" + getByForeach(new ArrayList<>(count), count) + "ms");
System.out.println("通过foreach遍历linkedList：" + getByForeach(new linkedList<>(), count) + "ms");
}
运行结果如下：
通过for循环遍历ArrayList：3.4403ms 通过for循环遍历linkedList：3563.1219ms 通过foreach遍历ArrayList：3.7388ms 通过foreach遍历linkedList：3.7953ms
我们可以看到，通过for循环遍历时，ArrayList的效率高于linkedList，而且linkedList的效率极低；通过foreach遍历时，ArrayList的效率和linkedList相差不大。
老徐：“阿珍，你知道为什么for循环遍历linkedList的效率那么低吗？”
阿珍：“因为linkedList基于链表实现的，每一次for循环都要遍历找到对应的节点，所以严重影响了遍历的效率；而ArrayList直接可以通过数组下标直接找到对应的元素，所以for循环效率非常高。对不对？”
老徐：“是的，所以我们不要使用for循环遍历linkedList。”
总结ArrayList是基于数组实现，linkedList是基于链表实现。
在ArrayList初始化容量足够的情况下，从头部新增元素时，ArrayList的效率低于linkedList；从中部新增元素时，ArrayList的效率高于linkedList；从尾部新增元素时，ArrayList的效率高于linkedList。
从头部删除元素时，ArrayList的效率低于linkedList；从中部删除元素时，ArrayList的效率高于linkedList；从尾部删除元素时，ArrayList的效率高于linkedList。
通过for循环遍历时，ArrayList的效率高于linkedList，而且linkedList的效率极低；通过foreach遍历时，ArrayList的效率和linkedList相差不大。
最后，谢谢你这么帅，还给我点赞和关注。
