Java里面LinkedList、ArrayList的效率分析

最新推荐文章于 2024-05-19 23:56:50 发布
最新推荐文章于 2024-05-19 23:56:50 发布
阅读量723 收藏
点赞数
分类专栏： java面向对象等技术 文章标签： arraylist 数据结构 链表 java linkedList
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tanqian351/article/details/51209829
版权

Java数据结构之LinkedList、ArrayList的效率分析

前言：

     在我们平常开发中难免会用到List集合来存储数据，一般都会选择ArrayList和LinkedList，以前只是大致知道ArrayList查询效率高LinkedList插入删除效率高，今天来实测一下。

先了解一下List     

  List列表类，顺序存储任何对象（顺序不变），可重复。

  List是继承于Collection的接口，不能实例化。实例化可以用:

  • ArrayList(实现动态数组)，查询快（随意访问或顺序访问），增删慢。整体清空快，线程不同步(非线程安全)。数组长度是可变的百分之五十延长
  • LinkedList（实现链表），查询慢，增删快。
  • Vector（实现动态数组），都慢，被ArrayList替代。长度任意延长。线程安全（同步的类，函数都是synchronized）
  • Stack（实现堆栈）继承于Vector，先进后出。

    List基本操作

  • 插入：add()
  • 查找：get()
  • 删除：remove(int index)
  • 修改：set()
  • 清空表：clear()
  • 遍历：用Iterator迭代器遍历每个元素

ArrayList、LinkedList性能对比

为了很好的对比效率，直接写个测试程序看下运行结果

代码1：模拟5w条数据指定插入最后一位，然后查询全部，循环从最后一位删除

 

public class TestList {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		testArrayList();
		testLinkedList();
	}

	private static void testLinkedList() {
		LinkedList<String> list = new LinkedList<>();
		int maxTestCount = 50000;

		// 测试添加
		long start = System.currentTimeMillis();

		for (int i = 0; i < maxTestCount; i++) {
			list.add(0, String.valueOf(i));
		}

		long end = System.currentTimeMillis();

		 System.out.println("LinkedList add cost time :" + (end - start));

		// 测试查询
		start = System.currentTimeMillis();

		for (int i = 0; i < maxTestCount; i++) {
			list.get(i);
		}

		end = System.currentTimeMillis();

		 System.out.println("LinkedList get cost time :" + (end - start));

		// 测试删除
		start = System.currentTimeMillis();

		for (int i = maxTestCount; i > 0; i--) {
			list.remove(0);
		}

		end = System.currentTimeMillis();

		 System.out.println("LinkedList remove cost time :" + (end - start));

	}
	
	
	
	private static void testArrayList(){
        ArrayList<String> list=new ArrayList<>();
        int maxTestCount=50000;

        //测试添加
        long start =System.currentTimeMillis();

        for(int i =0;i<maxTestCount;i++){
            list.add(i,String.valueOf(i));
        }

        long end =System.currentTimeMillis();

        System.out.println("ArrayList add cost time :"+(end-start));

        //测试查询
        start =System.currentTimeMillis();

        for(int i =0;i<maxTestCount;i++){
            list.get(i);
        }

        end =System.currentTimeMillis();

        System.out.println("ArrayList get cost time :"+(end-start));

        //测试删除
        start =System.currentTimeMillis();

        for(int i =maxTestCount;i>0;i--){
            list.remove(i-1);
        }

        end =System.currentTimeMillis();

        System.out.println("ArrayList remove cost time :"+(end-start));

    }

}

 

结果：

ArrayList add cost time :15
ArrayList get cost time :2
ArrayList remove cost time :3
LinkedList add cost time :10
LinkedList get cost time :2308
LinkedList remove cost time :2

代码2：模拟5w条数据指定插入第一位，然后查询全部，循环从第一位删除

public class TestList {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		testArrayList();
		testLinkedList();
	}

	private static void testLinkedList() {
		LinkedList<String> list = new LinkedList<>();
		int maxTestCount = 50000;

		// 测试添加
		long start = System.currentTimeMillis();

		for (int i = 0; i < maxTestCount; i++) {
			list.add(0, String.valueOf(i));
		}

		long end = System.currentTimeMillis();

		 System.out.println("LinkedList add cost time :" + (end - start));

		// 测试查询
		start = System.currentTimeMillis();

		for (int i = 0; i < maxTestCount; i++) {
			list.get(i);
		}

		end = System.currentTimeMillis();

		 System.out.println("LinkedList get cost time :" + (end - start));

		// 测试删除
		start = System.currentTimeMillis();

		for (int i = maxTestCount; i > 0; i--) {
			list.remove(0);
		}

		end = System.currentTimeMillis();

		 System.out.println("LinkedList remove cost time :" + (end - start));

	}
	
	
	
	private static void testArrayList(){
        ArrayList<String> list=new ArrayList<>();
        int maxTestCount=50000;

        //测试添加
        long start =System.currentTimeMillis();

        for(int i =0;i<maxTestCount;i++){
            list.add(0,String.valueOf(i));
        }

        long end =System.currentTimeMillis();

        System.out.println("ArrayList add cost time :"+(end-start));

        //测试查询
        start =System.currentTimeMillis();

        for(int i =0;i<maxTestCount;i++){
            list.get(i);
        }

        end =System.currentTimeMillis();

        System.out.println("ArrayList get cost time :"+(end-start));

        //测试删除 
        start =System.currentTimeMillis();

        for(int i =maxTestCount;i>0;i--){
            list.remove(0);
        }

        end =System.currentTimeMillis();

        System.out.println("ArrayList remove cost time :"+(end-start));

    }

}

结果：

ArrayList add cost time :168
ArrayList get cost time :2
ArrayList remove cost time :138
LinkedList add cost time :8
LinkedList get cost time :2636
LinkedList remove cost time :4

 

通过上面的运行结果可以大致得出以下结论：

  • ArrayList插入、删除效率，在每次都操作第一位元素的时候，明显低于LinkedList
  • ArrayList查询效率远远高于LinkedList

通过上面的结构是不是就可以认为插入删除频繁选择LinkedList，追求查询效率就选择ArrayList呢，我们先来分析一下效率差别的原因，这个就跟数据结构有关系了，可以参考一些数据结构中链表的知识，arraylist 顺序表，用数组的方式实现。想想数组要查询那个元素只给出其下标即可，所以才说arraylist随机访问多的场景比较合适。但是如果删除某个元素比如第 i 个元素，则要将 i 之后的元素都向前移一位以保证顺序表的正确，增加也是一样，增加还涉及到扩容的问题，要移动多个元素。要多次删除增加的话是很低效的。而LinkedList是双向链表，注意是链表。要查询只能头结点开始逐步查询，虽然linkedlist也有get(i)的方法，看起来也是根据下标去获取元素，但是它的get(i)底层是这样的：

    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }


    /**
     * Returns the (non-null) Node at the specified element index.
     */
    Node<E> node(int index) {
        // assert isElementIndex(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;
        }
    }

还是遍历了整个链表去获取元素，所以慢。但是，如果要增加后删除一个元素的话，只需要改变其前后元素的指向即可，不需要像arraylist那样整体移动，所以才说多用于增删多的场合。

 

List扩容

我们知道List集合的底层实现是数组结构，而数组的大小是不可改变的，因此当其容器内存不足时，需要进行扩容，扩容的方法就是重新分配一个新数组，然后复制元素到新数组中，再将元素添加到数组末位 
一、ArrayList 
首先便是默认大小的问题 
这里我们可以通过ArrayList的源码来分析，首先可以看一下他的构造函数，发现有三个，分别是：无参、一个int型参数、一个集合泛型； 
在分析构造函数之前 我们先来看几个参数： 
在 
即ArrayList 在内部的表示即为一个Object类型的数组，并非真正的泛型，这里的变量就是数组的真实存储大小 
这里写图片描述 
可以理解为设置默认数组大小的常量

1、无参的构造函数 
这里写图片描述 
在这里我们可以看到，当不传参数时，数组的大小直接为默认数组大小的常量，而这个大小就为10，至于怎么得到的，这里我们可以先卖个小关子，在后面一起介绍~~ 
2、有一个int的构造函数 
这里写图片描述 
我们可以发现，当传入的值大于0时，数组的大小即为传入的值大小，为0时，则为EMPTY_ELEMENTDATA，小于0则抛出异常。这个EMPTY_ELEMENTDATA又是什么意思呢？？ 
其实就是0(即亦可理解为传入的值)；

3、有一个Collection泛型的构造函数 
这里写图片描述 
而集合参数的其实与Int的构造函数差不多，只是在初始化容器的同时，还将容器中的数据也初始化了(完成copy)。

虽然说完了构造函数，但实际的扩容是发生在增加元素的时候(容器内存不足或者存储达到加载因子)，因此 来到了最为主要的一部分内容： 
4、ArrayList 的元素添加 
这里写图片描述 
通过上面的代码可以看到，每次添加元素的时候，都会执行一个方法，而这个方法，就是判断是否需要扩容的方法； 
这里写图片描述
进入方法之后，我们看到了一个if语句，发现了么，这个就是我们之前在无参构造函数时卖的关子，当当前的大小为默认数组大小的常量时，minCapacity（即位数组中存储的数据大小即size+1）就为DEFAULT_CAPACITY, minCapacity之间大的那个，而minCapacity的默认值为0，所以从这里就可以知道，无参构造函数产生的数组大小为10~~ 
但是真正的判断还不在这里，而是下面这个方法： 
这里写图片描述 
由此我们可以看出，其实就是判断加一个元素后，数组大小是够超出当前数组的大小，若超出，则执行下面的”扩容“代码~~ 
这里写图片描述

从文中我们可看到，新数组的大小其实就是（ oldCapacity + (oldCapacity >> 1)），如果你懂得位运算的话，你就知道了，原来就是原数组的长度加上原数组的长度大小的一半(位运算，右移一位相当于整体/2)，后面判断数组大小越界这里就不多阐述了，感兴趣的可以自己查看一下源码。 
上面的ArrayList是没有涉及加载因子的，但是有些集合类型如Vector等使用到了加载因子，只要把是否需要扩容d的判断条件改一下就可以了。 

总结：

   通过运行结果和查阅资料基本上验证了ArrayList和LinkedList效率问题，有助于在以后的开发中根据实际场景选择合适的技术方案，所以不能笼统的说arrayList适合查询元素，而linkedList适合增删元素。

谷神通
关注
专栏目录
详谈ArrayList和LinkedList的真正效率
hening191的博客
12-09 2699
说起ArrayList和LinkedList的效率，很多人都能说上如下图中的答案来： 该答案是搜索提供的推荐答案，也是很多人在初次去学习了解ArrayList和LinkedList区别时获得的答案。但这个答案真的正确吗？效率如何，我们从源码分析，然后再做测试看看。 我们今天着重研究一下add的效率。首先我们从源码来看看： 先看ArrayList的add方法: 如图，add方法中，先进行越界检查、然后再进行检查扩容工作、元素迁移，之后再赋值，把size属性++。 然后再看看LinkedList的add方法：
ArrayList与LinkedList的运行效率的对比
qq_41187393的博客
03-06 1572
ArrayList与LinkedList的运行效率的对比 1.ArrayList ​ 1.1.ArrayList的特点: ​ a.ArrayList的底层结构是 动态数组,既然是数组，那么就拥有数组的特点。数组的最重要的特点就是它是连续存储的，有下标的。 ​ b.元素可以重复 ​ c.有序的。其中，有序是指存放进去的顺序是有序的。跟排序是两不相干的，排序是指对集合中的元素进行排序。 ​ d...
ArrayList与LinkedList效率的对比
daijianzhou的专栏
05-25 3031
ArrayList与LinkedList效率的对比 看了网上很多文章都说，ArrayList的查询效率优于LinkedList，而增删效率低于LinkedList。这种说法其实是有问题的，ArrayList底层是数组，插入其实就是在尾部添加，确实在扩容的时候会损失一点效率，但这点损失基本不需要考虑。 下面将用百万数据进行一个测试 首先看增加 long s=System.currentTimeMillis(); ArrayList arrayList=new ArrayList();
LinkedList插入数据效率和ArrayList对比
初心不改
08-18 1068
1 在尾部插入数据时，数据量较小时LinkedList比较快，因为ArrayList要频繁扩容，当数据量较大时ArrayList比较快，因为ArrayList扩容是当前容量1.5倍，大容量扩一次就能提供很多空间，而LinkedList每次add时候会new Node当数据量大时，这里就会耗时较多了。3 插入越往中间，LinkedList效率越低，因为它遍历获取插入位置是从两端往中间搜，index越往中间遍历越久，因此ArrayList的插入效率可能比LinkedList高。
浅析ArrayList,LinkedList的执行效率
duanyugen的专栏
08-27 1416
以前见过很多文章说这两个东西，感觉自己还是没有深入理解，今天看了书明白一些，在此提出来和大家共同探讨：           面试的时候（基础）一般会问你使用过LinkedList或者ArrayList没有，简单的回答有或者没有肯定不是面试官的期望答案，一般有经验的小伙伴都会说，如果该集合进行的增删操作比较多，建议使用LinkedList，如果是查询较多建议使用ArrayList，原理就用下面两个
深入浅析ArrayList 和 LinkedList的执行效率比较
08-29
主要介绍了ArrayList 和 LinkedList的执行效率比较的相关资料,需要的朋友可以参考下
Java中ArrayList和LinkedList区别
12-22
在Java编程语言中，ArrayList和LinkedList都是集合框架中两种重要的列表实现，它们分别基于不同的数据结构，具有不同的特性和性能特点。以下是对这两个类的详细分析： 1. 数据结构： - ArrayList是基于动态数组的...
java中ArrayList与LinkedList对比详情
08-30
Java 中 ArrayList 与 LinkedList 对比详情 在 Java 中，ArrayList 和 LinkedList 是两个常用的集合实现方式，它们都实现了 Collection 接口，但是它们之间存在着一些关键的差异。本文将通过实例对比 Java 中 ...
LinkedList遍历效率
HUSJIH的专栏
08-08 775
LinkedList通常使用的遍历方式有两种：for循环遍历，即调用get方法；还有就是迭代器循环。建议采用迭代器循环，这个网上有很多比较数据说明，下面简单通过源码看一下原因。本文代码jdk8。 1:for循环遍历时调用get方法，下面看一下源代码 public E get(int index) { checkElementIndex(index); return
ArrayList和LinkedList的效率对比
进击的小宇宙
10-24 3307
一、 前言 首先我要批判一下很多关于这两个数据结构的对比测试文章，其作者在根本没搞清楚这俩内部实现原理和数据结构的情况下，用错误的方法测得结果，碰巧符合理论，因此认为符合，从而误导读者。之所以这么说，还请读者细读本文，之后便明白了。 二、 数据结构 ArrayList ArrayList在内存中是连续的、单向的、有序的。 ArrayList中维护了一个按照下标顺序的一维数组，数组中每个item指...
ArrayList与LinkedList的效率
侯春强的博客
08-07 291
public static void main(String[] args) { LinkedList linkedList = new LinkedList(); ArrayList arrayList = new ArrayList(); long l1 = System.currentTimeMillis(); for (int i = 0; i < 99999
毁三观的“ArrayList”与“LinkedList”，ArrayList与LinkedList的效率问题！
wjw89的博客
08-31 467
ArrayList查询效率快，增删效率慢；LinkedList查询效率慢，增删效率快，真的是这样吗
【ArrayList、LinkedList使用get()方法获取元素时的效率对比，以及源码分析】
Continueye的博客
07-23 583
代码】【ArrayList、LinkedList使用get()方法获取元素时的效率对比，以及源码分析】
Java LinkedList 与 ArrayList 效率比较
Hikes的博客
06-12 169
todolist
ArrayList效率分析与LinkedList性能对比
最新发布
weixin_38178449的博客
05-19 334
ArrayList与LinkedList对比
Java容器——ArrayList VS LinkedList（Java8） 性能比较
qisong3的专栏
05-30 593
ArrayList和LinkedList都继承自List， 内在实现机制有所不同，关于区别方面已经有很多优秀的文章进行了介绍。本文从实践角度出发，对比两种List在不同操作中的性能，便于读者在特定场景中参考选型。由于电脑配置，JDK版本，IDE等会导致测试结果又出入甚至有结论不太一致的结果，本文的试验结果仅具备一定的参考价值。     一 插入数据 以同样的方式向两种List中插入数据，首先插...
知识点（6）——LinkedList和ArrayList的效率差异性分析
u010257931的博客
02-19 486
前言 最近在看集合这一块，都知道LinkedList是双链表结构，可以用来实现栈、队列、双端队列（因为LinkedList实现了Deque，deque 即双端队列，是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行）。LinkedList随机访问效率低，但是插入、随机删除速度快。 而ArrayList是动态数组结构，实现了RandomAcce...
Java ArrayList与LinkedList性能对比分析
"本文将深入探讨Java中的ArrayList和LinkedList的区别，帮助开发者理解何时选择哪种数据结构。ArrayList基于动态数组，而LinkedList则是链表实现，两者在性能特性上有所不同。" 在Java编程中，ArrayList和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值