ArrayList与LinkedList性能分析

已于 2023-02-20 13:28:04 修改
阅读量1.2k 收藏 2
点赞数 1
分类专栏： Java 文章标签： java
于 2022-11-18 22:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44936392/article/details/127918091
版权

ArrayList与LinkedList性能分析

一. 面试题

作为程序员来说，这道面试题基本上都逃不过面试官的提问，而我们给出的答案基本上都是千篇一律，，看到这个面试题的时候我们也请扪心自问一下，我们该如何去回答，我们的答案自己都去验证了吗？

ArrayList和LinkedList的区别?

基本回答：

  • ArrayList底层是数组，增删慢，查找快。
  • LinkedList底层是双向链表，增删快，查找慢。

然后再去解释一下的数据结构以及存储原理，基本上认知也就结束了。

其实这只是片面的回答，它的具体性能还得用数据来说话，接下来我们从头部，中间，及尾部多个维度来探索以下ArrayList和LinkedList的性能问题。

二. 性能对比

接下来我们将用数据的量级测试ArrayList和LinkList的性能。

1. 数据插入
1. 头部插入法

代码演示：

package com.student.studentserver.test.list.add;

import com.student.studentserver.test.list.AddListUtil;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * @author gf
 * @date 2022/11/18
 */
public class HeaderAdd {

    public static void main(String[] args) {
        System.out.println("----------10w----------");
        useTime(100000);
        System.out.println("----------30w----------");
        useTime(300000);
        System.out.println("----------50w----------");
        useTime(500000);
        System.out.println("----------100w----------");
        useTime(1000000);

    }

    public static void useTime(int count){
        System.out.println("从ArrayList的头部新增耗时：" + addHeader(new ArrayList<>(), count) + "ms");
        System.out.println("从LinkedList的头部新增耗时：" + addHeader(new LinkedList<>(), count) + "ms");
    }

    /**
     * 从List的头部新增元素
     * @param list list
     * @param count 新增元素的个数
     * @return 所耗费的时间（单位：ms）
     */
    public static long addHeader(List<String> list, int count) {
       long start = System.currentTimeMillis();
        for (int i = 0; i < count; i++) {
            list.add(0, "onemore-" + i);
        }
        long end =  System.currentTimeMillis();
        return (end - start);
    }
}

数据统计：数据量/w , 耗时/ms

----------10w----------
从ArrayList的头部新增耗时：520ms
从LinkedList的头部新增耗时：21ms
----------30w----------
从ArrayList的头部新增耗时：4006ms
从LinkedList的头部新增耗时：28ms
----------50w----------
从ArrayList的头部新增耗时：13099ms
从LinkedList的头部新增耗时：21ms
----------100w----------
从ArrayList的头部新增耗时：57205ms
从LinkedList的头部新增耗时：600ms

Process finished with exit code 0
数量级（万）ArrayListLinkedList
10520 ms21ms
304006 ms28 ms
5013099 ms21 ms
10057205 ms600 ms

结果：头部插入法LinkedList效率远高于ArrayList

2. 尾部插入法

代码演示：

package com.student.studentserver.test.list.add;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

package com.student.studentserver.test.list.add;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * @author gf
 * @date 2022/11/18
 */
public class TailAdd {
    public static void main(String[] args) {
        System.out.println("----------1w----------");
        useTime(10000);
        System.out.println("----------5w----------");
        useTime(50000);
        System.out.println("----------10w----------");
        useTime(100000);
        System.out.println("----------15w----------");
        useTime(150000);
        System.out.println("----------20w----------");
        useTime(200000);
        System.out.println("----------30w----------");
        useTime(300000);
        System.out.println("----------50w----------");
        useTime(500000);
        System.out.println("----------70w----------");
        useTime(700000);
        System.out.println("----------100w----------");
        useTime(1000000);
    }

    public static void useTime(int count){
        System.out.println("从ArrayList的尾部新增耗时：" + addTail(new ArrayList<>(), count) + "ms");
        System.out.println("从LinkedList的尾部新增耗时：" + addTail(new LinkedList<>(), count) + "ms");
    }

    /**
     * 从List的尾部新增元素
     * @param list list
     * @param count 新增元素的个数
     * @return 所耗费的时间（单位：ms）
     */
    public static long addTail(List<String> list, int count) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < count; i++) {
            list.add("tail-" + i);
        }
        long end = System.currentTimeMillis();
        return (end - start);
    }
}

测试结果：

----------1w----------
从ArrayList的尾部新增耗时：5ms
从LinkedList的尾部新增耗时：4ms
----------5w----------
从ArrayList的尾部新增耗时：10ms
从LinkedList的尾部新增耗时：4ms
----------10w----------
从ArrayList的尾部新增耗时：15ms
从LinkedList的尾部新增耗时：4ms
----------15w----------
从ArrayList的尾部新增耗时：5ms
从LinkedList的尾部新增耗时：23ms
----------20w----------
从ArrayList的尾部新增耗时：7ms
从LinkedList的尾部新增耗时：9ms
----------30w----------
从ArrayList的尾部新增耗时：11ms
从LinkedList的尾部新增耗时：27ms
----------50w----------
从ArrayList的尾部新增耗时：13ms
从LinkedList的尾部新增耗时：68ms
----------70w----------
从ArrayList的尾部新增耗时：23ms
从LinkedList的尾部新增耗时：379ms
----------100w----------
从ArrayList的尾部新增耗时：48ms
从LinkedList的尾部新增耗时：120ms

Process finished with exit code 0

结果：从数据测试来看， 对于尾插法而言，不是说ArrayList就一定比LinkedList效率高，经过大量的数据测试，发现10w以内LinkedList比ArrayList快，100w以上ArrayList明显比LinkedList快。

2. 数据删除
1. 头部删除法

代码演示：

package com.student.studentserver.test.list.del;

import com.student.studentserver.test.list.DeleteListUtil;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * @author gf
 * @date 2022/11/18
 */
public class DelList {

    public static void main(String[] args) {
        System.out.println("----------1w----------");
        delToList(10000);
        System.out.println("----------5w----------");
        delToList(50000);
        System.out.println("----------10w----------");
        delToList(100000);
        System.out.println("----------15w----------");
        delToList(150000);
        System.out.println("----------20w----------");
        delToList(200000);
        System.out.println("----------30w----------");
        delToList(300000);
        System.out.println("----------50w----------");
        delToList(500000);
        System.out.println("----------70w----------");
        delToList(700000);
        System.out.println("----------100w----------");
        delToList(1000000);

    }

    public static void delToList(int count){

        System.out.println("从ArrayList的头部删除元素：" + deleteHeader(new ArrayList<>(), count) + "ms");
        System.out.println("从LinkedList的头部删除元素：" + deleteHeader(new LinkedList<>(), count) + "ms");

    }

    /**
     * 从List的头部删除元素
     * @param list list
     * @param count 删除元素的个数
     * @return 所耗费的时间（单位：ms）
     */
    public static double deleteHeader(List<String> list, int count) {
        for (int i = 0; i < count; i++) {
            list.add("del-" + i);
        }
        long start = System.currentTimeMillis();
        for (int i = 0; i < count; i++) {
            list.remove(0);
        }
        long end = System.currentTimeMillis();
        return (end - start);
    }

}

测试结果：

----------1w----------
从ArrayList的头部删除元素：6.0ms
从LinkedList的头部删除元素：1.0ms
----------5w----------
从ArrayList的头部删除元素：79.0ms
从LinkedList的头部删除元素：2.0ms
----------10w----------
从ArrayList的头部删除元素：416.0ms
从LinkedList的头部删除元素：4.0ms
----------15w----------
从ArrayList的头部删除元素：875.0ms
从LinkedList的头部删除元素：2.0ms
----------20w----------
从ArrayList的头部删除元素：1587.0ms
从LinkedList的头部删除元素：5.0ms
----------30w----------
从ArrayList的头部删除元素：3623.0ms
从LinkedList的头部删除元素：6.0ms
----------50w----------
从ArrayList的头部删除元素：11891.0ms
从LinkedList的头部删除元素：8.0ms
----------70w----------
从ArrayList的头部删除元素：26807.0ms
从LinkedList的头部删除元素：15.0ms
----------100w----------
从ArrayList的头部删除元素：56940.0ms
从LinkedList的头部删除元素：30.0ms

Process finished with exit code 0

结果：从数据测试来看，头部删除LinkedList比ArrayList快

2. 尾部删除法

代码演示：

package com.student.studentserver.test.list.del;

import com.student.studentserver.test.list.DeleteListUtil;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * @author gf
 * @date 2022/11/18
 */
public class DelList {

    public static void main(String[] args) {
        System.out.println("----------1w----------");
        delToList(10000);
        System.out.println("----------5w----------");
        delToList(50000);
        System.out.println("----------10w----------");
        delToList(100000);
        System.out.println("----------15w----------");
        delToList(150000);
        System.out.println("----------20w----------");
        delToList(200000);
        System.out.println("----------30w----------");
        delToList(300000);
        System.out.println("----------50w----------");
        delToList(500000);
        System.out.println("----------70w----------");
        delToList(700000);
        System.out.println("----------100w----------");
        delToList(1000000);

    }

    public static void delToList(int count){

        System.out.println("从ArrayList的尾部删除元素：" + deleteTail(new ArrayList<>(), count) + "ms");
        System.out.println("从LinkedList的尾部删除元素：" + deleteTail(new LinkedList<>(), count) + "ms");

    }


    /**
     * 从List的尾部删除元素
     * @param list list
     * @param count 删除元素的个数
     * @return 所耗费的时间（单位：ms）
     */
    public static double deleteTail(List<String> list, int count) {
        for (int i = 0; i < count; i++) {
            list.add("del-" + i);
        }
        long start = System.currentTimeMillis();;
        for (int i = 0; i < count; i++) {
            list.remove(list.size() - 1);
        }
        long end = System.currentTimeMillis();;
        return (end - start);
    }
}

测试结果：

----------1w----------
从ArrayList的尾部删除元素：1.0ms
从LinkedList的尾部删除元素：2.0ms
----------5w----------
从ArrayList的尾部删除元素：1.0ms
从LinkedList的尾部删除元素：8.0ms
----------10w----------
从ArrayList的尾部删除元素：0.0ms
从LinkedList的尾部删除元素：6.0ms
----------15w----------
从ArrayList的尾部删除元素：1.0ms
从LinkedList的尾部删除元素：4.0ms
----------20w----------
从ArrayList的尾部删除元素：0.0ms
从LinkedList的尾部删除元素：4.0ms
----------30w----------
从ArrayList的尾部删除元素：1.0ms
从LinkedList的尾部删除元素：14.0ms
----------50w----------
从ArrayList的尾部删除元素：1.0ms
从LinkedList的尾部删除元素：57.0ms
----------70w----------
从ArrayList的尾部删除元素：2.0ms
从LinkedList的尾部删除元素：29.0ms
----------100w----------
从ArrayList的尾部删除元素：4.0ms
从LinkedList的尾部删除元素：27.0ms

Process finished with exit code 0

结果：从数据测试来看，尾部删除ArrayList比LinkedList快

3. 数据检索
1. for 循环遍历List

代码演示：

package com.student.studentserver.test.list.query;

import com.student.studentserver.test.list.IterationListUtil;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * @author gf
 * @date 2022/11/18
 */
public class QueryList {


    public static void main(String[] args) {
        System.out.println("----------1w----------");
        IteratToList(10000);
        System.out.println("----------5w----------");
        IteratToList(50000);
        System.out.println("----------10w----------");
        IteratToList(100000);
        System.out.println("----------15w----------");
        IteratToList(150000);
    }

    public static void IteratToList(int count){

        System.out.println("通过for循环遍历ArrayList：" + getByFor(new ArrayList<>(count), count) + "ms");
        System.out.println("通过for循环遍历LinkedList：" + getByFor(new LinkedList<>(), count) + "ms");

    }

    /**
     * 通过for循环遍历List
     *
     * @param list  list
     * @param count 遍历元素的个数
     * @return 所耗费的时间（单位：ms）
     */
    public static double getByFor(List<String> list, int count) {
        for (int i = 0; i < count; i++) {
            list.add("for-" + i);
        }
        String name = "本草中国";
        long start = System.currentTimeMillis();
        for (int i = 0; i < count; i++) {
            if (name.equals(list.get(i))) {
                System.out.println(name);
            }
        }
        long end = System.currentTimeMillis();
        return (end - start);
    }
}

测试结果：

----------1w----------
通过for循环遍历ArrayList：1.0ms
通过for循环遍历LinkedList：43.0ms
----------5w----------
通过for循环遍历ArrayList：1.0ms
通过for循环遍历LinkedList：1924.0ms
----------10w----------
通过for循环遍历ArrayList：1.0ms
通过for循环遍历LinkedList：11731.0ms
----------15w----------
通过for循环遍历ArrayList：1.0ms
通过for循环遍历LinkedList：13699.0ms

Process finished with exit code 0

结果：从数据测试来看，通过for循环遍历时，ArrayList的效率高于LinkedList,而且LinkedList的效率极低。

2. foreach 循环遍历List

代码演示：

package com.student.studentserver.test.list.query;

import com.student.studentserver.test.list.IterationListUtil;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * @author gf
 * @date 2022/11/18
 */
public class QueryList {


    public static void main(String[] args) {
        System.out.println("----------1w----------");
        IteratToList(10000);
        System.out.println("----------5w----------");
        IteratToList(50000);
        System.out.println("----------10w----------");
        IteratToList(100000);
        System.out.println("----------50w----------");
        IteratToList(500000);
        System.out.println("----------100w----------");
        IteratToList(1000000);
    }

    public static void IteratToList(int count){

        System.out.println("通过foreach遍历ArrayList：" + getByForeach(new ArrayList<>(count), count) + "ms");
        System.out.println("通过foreach遍历LinkedList：" + getByForeach(new LinkedList<>(), count) + "ms");
    }

    /**
     * 通过foreach遍历List
     *
     * @param list  list
     * @param count 遍历元素的个数
     * @return 所耗费的时间（单位：ms）
     */
    public static double getByForeach(List<String> list, int count) {
        for (int i = 0; i < count; i++) {
            list.add("foreach-" + i);
        }
        String name = "本草中国";
        long start = System.currentTimeMillis();
        for (String str : list) {
            if (name.equals(str)) {
                System.out.println(name);
            }
        }
        long end = System.currentTimeMillis();
        return (end - start);
    }
}

测试结果：

----------1w----------
通过foreach遍历ArrayList：2.0ms
通过foreach遍历LinkedList：2.0ms
----------5w----------
通过foreach遍历ArrayList：1.0ms
通过foreach遍历LinkedList：5.0ms
----------10w----------
通过foreach遍历ArrayList：2.0ms
通过foreach遍历LinkedList：10.0ms
----------50w----------
通过foreach遍历ArrayList：4.0ms
通过foreach遍历LinkedList：7.0ms
----------100w----------
通过foreach遍历ArrayList：5.0ms
通过foreach遍历LinkedList：9.0ms

Process finished with exit code 0

结果：从数据测试来看，通过foreach遍历时，ArrayList的效率和LinkedList相差不大。

三. 总结

ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

新增元素：

  • 头插法：LinkedList效率远高于ArrayList
  • 尾插法：对于尾插法而言，不是说ArrayList就一定比LinkedList效率高，经过大量的数据测试，发现10w以内LinkedList比ArrayList快，100w以上ArrayList明显比LinkedList快。

删除元素：

  • 头部删除：头部删除LinkedList比ArrayList快
  • 尾部删除：尾部删除ArrayList比LinkedList快

通过for循环遍历时，ArrayList的效率高于LinkedList，而且LinkedList的效率极低；通过foreach遍历时，ArrayList的效率和LinkedList相差不大。所以请避免使用for循环遍历LinkedList集合。

思考：java中的for循环和foreach循环有什么区别呢？

浪浪山的猿
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ArrayList与LinkedList的运行效率的对比
qq_41187393的博客
03-06 1466
ArrayList与LinkedList的运行效率的对比 1.ArrayList ​ 1.1.ArrayList的特点: ​ a.ArrayList的底层结构是 动态数组,既然是数组，那么就拥有数组的特点。数组的最重要的特点就是它是连续存储的，有下标的。 ​ b.元素可以重复 ​ c.有序的。其中，有序是指存放进去的顺序是有序的。跟排序是两不相干的，排序是指对集合中的元素进行排序。 ​ d...
Java中ArrayList和LinkedList的遍历与性能分析
09-01
主要给大家介绍了ArrayList和LinkedList这两种list的五种循环遍历方式，各种方式的性能测试对比，根据ArrayList和LinkedList的源码实现分析性能结果，总结结论。相信对大家的理解和学习具有一定的参考价值，有需要的...
java 中ArrayList与LinkedList性能比较
08-31
主要介绍了java 中ArrayList与LinkedList性能比较的相关资料,需要的朋友可以参考下
ArrayList 和 LinkedList对比
weixin_46906359的博客
03-12 593
ArrayList和LinkedList对比
ArrayList和LinkedList
Hi_ZaiJian的专栏
08-21 672
第1部分 List概括 List的框架图 List 是一个接口，它继承于Collection的接口。它代表着有序的队列。 AbstractList 是一个抽象类，它继承于AbstractCollection。AbstractList实现List接口中除size()、get(int location)之外的函数。 AbstractSequentialList 是一个抽象类，它继承于Abs
ArrayList和LinkedList使用不当，性能差距会如此之大！
HollisChuang's Blog
07-29 452
前言在面试的时候，经常会被问到几个问题：ArrayList和LinkedList的区别，相信大部分朋友都能回答上：ArrayList是基于数组实现，LinkedList是基于链表实现当随机...
ArrayList 和 LinkedList 的区别是什么？
qq_51824841的博客
06-09 1128
当对数据进行增加和删除的操作(add和remove操作)时，LinkedList比ArrayList的效率更高，因为ArrayList是数组，所以在其中进行增删操作时，4、在前方插入时，ArrayList可以使用后方插入，最后再使用Collections.reverse()方法反转，速度依然完爆LinkedList。ArrayList自由性较低，因为它需要手动的设置固定大小的容量，但是它的使用比较方便，只需要创建，然后添加数据，通过调用下标进行使用；4、主要控件开销不同。
LinkedList插入数据效率和ArrayList对比
初心不改
08-18 660
1 在尾部插入数据时，数据量较小时LinkedList比较快，因为ArrayList要频繁扩容，当数据量较大时ArrayList比较快，因为ArrayList扩容是当前容量1.5倍，大容量扩一次就能提供很多空间，而LinkedList每次add时候会new Node当数据量大时，这里就会耗时较多了。3 插入越往中间，LinkedList效率越低，因为它遍历获取插入位置是从两端往中间搜，index越往中间遍历越久，因此ArrayList的插入效率可能比LinkedList高。
ArrayList、LinkedList，及其它们的区别（在效率、底层、空间等方面）
yu的博客
08-11 1258
对ArrayList、LinkedList的介绍，以及它们之间的区别
ArrayList跟LinkedList性能测试对比
fouling的博客
07-19 629
不同数据量对比ArryaList跟LinkedList，增删查速度
ArrayList LinkedList Vector性能测试
05-03
比较ArrayList,LinkedList,Vector三者随机读取，插入，删除性能。
JAVA LinkedList和ArrayList的使用及性能分析
09-04
JAVA LinkedList和ArrayList的使用及性能分析，这篇文章也是以JAVA List的总结。
ArrayList LinkedList Vector性能对比
03-29
NULL 博文链接：https://lf6627926.iteye.com/blog/1297695
Day25-Java基础之常用类1
m0_46053885的博客
04-27 1124
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
最新发布
yajunjiao的专栏
04-30 503
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1100
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
Java解决最长公共前缀
无人罪的博客
04-28 396
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 910
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
ArrayList与LinkedList区别
08-19
ArrayList和LinkedList是Java中两种常见的集合类，它们都实现了List接口。它们之间的主要区别在于底层数据结构和性能方面。 1. 底层数据结构： - ArrayList底层使用数组来实现，连续的内存空间存储元素。 - ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值