Java中List效率的比较

最新推荐文章于 2023-06-01 14:45:36 发布
最新推荐文章于 2023-06-01 14:45:36 发布
阅读量631 收藏
点赞数
分类专栏： java

Java中List效率的比较

 
Java Collections Framework(JCF) 是Java SE中一个基本的类集，几乎所有的项目都会用到，其中的List 则是JCF中最最常用的一个接口。围绕List 接口，有很多实现，诸如常用的ArrayList 、LinkedList 、Vector 、Stack ，还有Java5之后引入的CopyOnWriteArrayList ，也有不少List 的开源实现，如Apache commons-collections中的各类List 
　　这么多的List 实现，如何选择？他们的运行效率具体怎样？本篇文章将用具体的代码来检测其中最最常用的一些List 实现 

主要测试对象： 
　　java.util.ArrayList; 
　　java.util.LinkedList; 
　　java.util.Stack; 
　　java.util.Vector; 
　　java.util.concurrent.CopyOnWriteArrayList; 
　　org.apache.commons.collections.FastArrayList; 
　　org.apache.commons.collections.list.TreeList; 
测试用例： 
　　1.测试List 
　　　1.1顺序添加 
　　　1.2随机插入 
　　　1.3随机删除 
　　　1.4随机访问 
　　　1.5随机更新 
　　　1.5顺序迭代 
      1.6for顺序迭代 

　　2.测试List 在三种情况下的排序效率 
　　　2.1初始时List 中元素已从小到大有序排列（最优情况） 
　　　2.2初始时List 中元素已从大到小有序排列（最差情况） 
　　　2.3初始时List 中元素随机排列，无序 
　　3.测试List 互相转换的效率 
　　　3.1转化为TreeList 
　　　3.2转化为ArrayList 
　　　3.3转化为LinkedList 
　　　3.4转化为CopyOnWriteArrayList 
　　　3.5转化为Vector 
测试代码： 
Java代码   收藏代码
  1. import static java.lang.System.out;    
  2. import java.util.ArrayList;    
  3. import java.util.Collections;    
  4. import java.util.Iterator;    
  5. import java.util.LinkedList;    
  6. import java.util.List;    
  7. import java.util.Stack;    
  8. import java.util.Vector;    
  9. import java.util.concurrent.CopyOnWriteArrayList;    
  10. import org.apache.commons.collections.FastArrayList;    
  11. import org.apache.commons.collections.list.TreeList;    
  12. import org.apache.commons.lang.StringUtils;    
  13. import org.apache.commons.lang.time.StopWatch;    
  14. @SuppressWarnings("unchecked")    
  15. public class ListPerformance {    
  16.     public static void main(String[] args) {    
  17.         ListPerformance test = new ListPerformance(10 * 10000);    
  18.         out.print(StringUtils.center("Test List Performance: loop=" + test.loop, 80, '-'));    
  19.         out.printf("\n ssssssss", "", "add", "insert", "remove", "get", "set",    
  20.                 "iterator","for");    
  21.         test.benchmark(new FastArrayList());    
  22.         test.benchmark(new TreeList());    
  23.         test.benchmark(new ArrayList());    
  24.         test.benchmark(new LinkedList());    
  25.         test.benchmark(new CopyOnWriteArrayList());    
  26.         test.benchmark(new Vector());    
  27.         test.benchmark(new Stack());    
  28.         //2.测试排序    
  29.         out.print("\n\n");    
  30.         out.print(StringUtils.center("Test List sort Performance: loop=" + test.loop, 80, '-'));    
  31.         out.printf("\n ssss", "", "optimize", "worst", "random");    
  32.         test.benchmarkSort(new FastArrayList());    
  33.         test.benchmarkSort(new TreeList());    
  34.         test.benchmarkSort(new ArrayList());    
  35.         test.benchmarkSort(new LinkedList());    
  36.         //test.benchmarkSort(new CopyOnWriteArrayList());//UnsupportedOperationException    
  37.         test.benchmarkSort(new Vector());    
  38.         test.benchmarkSort(new Stack());    
  39.         //3.测试各种数据结构间转化    
  40.         out.print("\n\n");    
  41.         out.print(StringUtils.center("Test List convert Performance: loop=" + test.loop, 80, '-'));    
  42.         out.printf("\n ssssss", "", "Tree", "Array", "Linked", "CopyOnWrite",    
  43.                 "Vector");    
  44.         test.benchmarkConvert(new FastArrayList());    
  45.         test.benchmarkConvert(new TreeList());    
  46.         test.benchmarkConvert(new ArrayList());    
  47.         test.benchmarkConvert(new LinkedList());    
  48.         test.benchmarkConvert(new CopyOnWriteArrayList());    
  49.     }    
  50.        
  51.     private int loop = 10000;    
  52.     public ListPerformance(int loop) {    
  53.         this.loop = loop;    
  54.     }    
  55.     public void benchmark(List list) {    
  56.         out.printf("\n s", list.getClass().getSimpleName());    
  57.         int j;    
  58.         StopWatch watch = null;    
  59.         //1.测试顺序性能(Add)    
  60.         (watch = new StopWatch()).start();    
  61.         for (int i = 0; i < loop; i++) {    
  62.             list.add(new Integer(i));    
  63.         }    
  64.         watch.stop();    
  65.         out.printf("d", watch.getTime());    
  66.         //2.测试随机插入性能(Random insert)    
  67.         (watch = new StopWatch()).start();    
  68.         for (int i = 0; i < loop; i++) {    
  69.             j = (int) (Math.random() * loop);    
  70.             list.add(j, new Integer(-j));    
  71.         }    
  72.         watch.stop();    
  73.         out.printf("d", watch.getTime());    
  74.         //3.测试随机索引删除(Random remove)    
  75.         (watch = new StopWatch()).start();    
  76.         for (int i = 0; i < loop; i++) {    
  77.             j = (int) (Math.random() * loop);    
  78.             list.remove(j);    
  79.         }    
  80.         watch.stop();    
  81.         out.printf("d", watch.getTime());    
  82.         //4.测试随机取数性能(Random get)    
  83.         (watch = new StopWatch()).start();    
  84.         for (int i = 0; i < loop; i++) {    
  85.             j = (int) (Math.random() * loop);    
  86.             list.get(j);    
  87.         }    
  88.         watch.stop();    
  89.         out.printf("d", watch.getTime());    
  90.         //5.测试随机更新性能(Random set)    
  91.         (watch = new StopWatch()).start();    
  92.         for (int i = 0; i < loop; i++) {    
  93.             j = (int) (Math.random() * loop);    
  94.             list.set(j, j);    
  95.         }    
  96.         watch.stop();    
  97.         out.printf("d", watch.getTime());    
  98.         //6.测试迭代性能(Iterator)    
  99.         (watch = new StopWatch()).start();    
  100.         Iterator<Object> iter = list.iterator();    
  101.         while (iter.hasNext()) {    
  102.             iter.next();    
  103.         }    
  104.         watch.stop();    
  105.         out.printf("d", watch.getTime());  
  106.       //7.测试迭代性能(Iterator)    
  107.         (watch = new StopWatch()).start();    
  108.      //   Iterator<Object> iter = list.iterator();    
  109.         for (Object obj : list) {    
  110.             
  111.         }    
  112.         watch.stop();    
  113.         out.printf("d", watch.getTime());  
  114.     }    
  115.     public void benchmarkConvert(List list) {    
  116.         out.printf("\n s", list.getClass().getSimpleName());    
  117.         StopWatch watch = null;    
  118.         //1.转TreeList    
  119.         (watch = new StopWatch()).start();    
  120.         new TreeList(list);    
  121.         watch.stop();    
  122.         out.printf("d", watch.getTime());    
  123.         //2.转ArrayList    
  124.         (watch = new StopWatch()).start();    
  125.         new ArrayList(list);    
  126.         watch.stop();    
  127.         out.printf("d", watch.getTime());    
  128.         //3.转LinkedList    
  129.         (watch = new StopWatch()).start();    
  130.         new LinkedList(list);    
  131.         watch.stop();    
  132.         out.printf("d", watch.getTime());    
  133.         //4.转CopyOnWriteArrayList    
  134.         (watch = new StopWatch()).start();    
  135.         new CopyOnWriteArrayList(list);    
  136.         watch.stop();    
  137.         out.printf("d", watch.getTime());    
  138.         //5.转Vector    
  139.         (watch = new StopWatch()).start();    
  140.         new Vector(list);    
  141.         watch.stop();    
  142.         out.printf("d", watch.getTime());    
  143.     }    
  144.     public void benchmarkSort(List list) {    
  145.         out.printf("\n s", list.getClass().getSimpleName());    
  146.         StopWatch watch = null;    
  147.         //1.顺序List    
  148.         for (int i = 0; i < loop; i++) {    
  149.             list.add(new Integer(i));    
  150.         }    
  151.         (watch = new StopWatch()).start();    
  152.         Collections.sort(list);    
  153.         watch.stop();    
  154.         out.printf("d", watch.getTime());    
  155.         //2.逆序List    
  156.         for (int i = loop - 1; i > 0; i--) {    
  157.             list.add(new Integer(i));    
  158.         }    
  159.         (watch = new StopWatch()).start();    
  160.         Collections.sort(list);    
  161.         watch.stop();    
  162.         out.printf("d", watch.getTime());    
  163.         //3.随机顺序List    
  164.         for (int i = 0, j = 0; i < loop; i++) {    
  165.             j = (int) (Math.random() * loop);    
  166.             list.add(new Integer(j));    
  167.         }    
  168.         (watch = new StopWatch()).start();    
  169.         Collections.sort(list);    
  170.         watch.stop();    
  171.         out.printf("d", watch.getTime());    
  172.     }    
  173. }   




测试结果： 
-----------------------Test List Performance: loop=100000----------------------- 
                           add    insert    remove       get       set  iterator       for 
       FastArrayList        31     16344     16312        47        62         0         0 
            TreeList       156       391       281       109       110        15         0 
           ArrayList        47     16406     16500        16        47        16         0 
          LinkedList        15    149719    264203    176125    179406         0        31 
CopyOnWriteArrayList     27422    141797    160906        31     65375         0         0 
              Vector        16     26391     24437        31        47        16         0 
               Stack        31     25094     22703        31        16        16         0 
--------------------Test List sort Performance: loop=100000--------------------- 
                      optimize     worst    random 
       FastArrayList        31        78       188 
            TreeList        32        94       343 
           ArrayList        16        94       172 
          LinkedList        16       266       219 
              Vector        15        78       219 
               Stack        15        94       156 
-------------------Test List convert Performance: loop=100000------------------- 
                          Tree     Array    LinkedCopyOnWrite    Vector 
       FastArrayList         0         0         0         0         0 
            TreeList         0         0         0         0         0 
           ArrayList         0         0         0         0         0 
          LinkedList         0         0         0         0         0 
CopyOnWriteArrayList         0         0         0         0         0 





结论： 
　　1.随机插入、随机删除操作中，用TreeList 效率最高； 
　　2.在只需要追加、迭代的环境下，LinkedList 效率最高； 
　　3.平均效率来讲，ArrayList 相对平衡，但如果海量随机操作，还是会造成性能瓶颈； 
　　4.CopyOnWriteArrayList 因为线程安全的原因，致使性能降低很多，所以慎用； 
　　5.Vector 没有传说中那么低的效率； 
　　6.让Stack 来做List 的事可以，不过语义上Stack 不应该做过多的List 的事情； 
　　7.在排序中，ArrayList 具有最好的性能，TreeList 平均性能也不错，LinkedList 的排序效率受元素初始状态的影响很大。 
　　8.各种List 间转换几乎没有时间损耗。 

注：增强性for循环其实是对iterator循环的一种简单写法，在编译时增强性for循环会被编译为iterator的for循环写法。在测试结果中两者变现出来的性能有一点相差（不正确，有时变现的快，有时变现的慢一点，可能与其他因素有关系），从理论上说，应该基本一样。 
引用地址：http://ldbjakyo.iteye.com/blog/1142899

http://blog.sina.com.cn 
騒粘虎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java list 遍历效率_Java遍历List四种方法的效率对比
weixin_29500837的博客
02-24 2179
Java遍历List的方法主要有：for eachjavafor(bject o :list)node{数组}oopIterator性能Iterator iter = list.iterator();测试while(iter.hasNext()){spaObject o = iter.next();.net}设计loop without sizecodeint size = list.size()...
java list 效率_Java中List集合性能比较
weixin_28811757的博客
02-12 1434
List是一个元素有序，可重复集合，集合中每个元素都有其对应的顺序索引，List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素vara=newArrayList();a.add(newString("zxc"));System.out.println(a.indexOf(newString("zxc")));这段代码，程序试图返回zxc的位置，但实际上List并未包含该字符串对...
Java中的List集合
qq_41571224的博客
12-19 1万+
List2.1 List集合概述和特点2.2List集合特有方法案例：List集合存储学生对象并遍历2.3并发修改异常 2.1 List集合概述和特点 public interface List<E> extends Collection<E> ~List有序集合也称为序列。该界面的用户可以精确的控制列表中每个元素的插入位置。用户可以通过整数索引访问元素。并搜索列表中的元素。 ~与Set集合不同，列表通常允许重复元素。 List集合特点： 有序：存储和取出的元素顺序一致； 可重复：
深入了解Java中的List集合
技术随笔
06-01 2782
Java中的List集合是一种常用的数据结构，它提供了一种有序、可重复的元素集合。在开发中，我们经常需要使用List来存储和操作一组数据。本文将深入介绍Java中List集合的特性、常见的操作方法以及一些使用技巧，帮助读者更好地理解和应用List集合。
Java中List集合Stream流详解
m0_71777195的博客
09-29 1万+
在JDK8时，JAVA新增了lambda表达式，它与 java.io 包里的和是完全不同的概念，他更跟流没有任何关系。它也不同于 StAX 对 XML解析的 Stream，也不是对大数据实时处理的Stream。JDK8 中的 Stream 是对集合（Collection）对象功能的增强，它借助于lambda表达式，更优雅的表达风格，极大的提高编程效率和程序可读性。它针对于对集合对象进行各种非常便利、高效的聚合操作，或者大批量数据操作。不多说，上用法。
java set list 效率_java 常用集合list与Set、Map区别及适用场景总结
weixin_32689769的博客
02-24 1613
1、List,Set都是继承自Collection接口，Map则不是2、List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复，重复元素会覆盖掉，(注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的，加入Set的Object必须定义equals()方法，另外list支持for循环，也就是通过下标来遍历，也可以用...
Java中List的简述
热门推荐
m0_47087822的博客
05-07 1万+
什么是 List 什么是集合 什么是 List List的继承、实现关系 List的种类 List的简单实用
Java 中 List 集合 Stream 流详解
weixin_51423778的博客
10-08 3160
Java 中 List 集合 Stream 流详解
Java中的List
qq_45720234的博客
08-29 3247
List：ArrayList、LinledList、Vector
Java中对List集合的常用操作详解
09-02
在Java编程中，List集合是Java集合框架的重要组成部分，它是一种有序的集合，可以存储重复的元素。本文将深入解析Java中对List集合的常用操作，帮助开发者更好地理解和使用List接口。 1. **添加、获取和删除元素** ...
java开发List提高效率
07-13
提高 List 转换效率是 Java 开发中非常重要的一方面，本文将讨论如何将 List 转换为逗号分隔的字符串，并提高开发效率。 首先，为什么需要将 List 转换为逗号分隔的字符串？因为在实际开发中，我们经常需要将数据...
Java判断List中相同值元素的个数实例
08-27
在Java编程中，有时我们需要统计一个List集合中相同值出现的次数。这在处理数据集、分析重复项或进行数据清洗时非常常见。本篇文章将详细介绍如何通过Java实现这一功能，特别是利用Map数据结构来高效地计算List中...
Java判断List中有无重复元素的方法
08-27
在Java编程中，处理列表(List)数据结构时，有时我们需要检查列表中是否存在重复的元素。本文将详细讲解如何使用Java来判断一个List中是否有重复的元素，并提供一种实用的实现方法。 首先，我们要理解Java中的List...
Java中List的使用方法简单介绍
09-02
Java中的List接口是Java集合框架（Collection Framework）的一部分，它是一个有序的集合，允许有重复的元素。List接口继承自Collection接口，提供了更多的特性和功能。List的主要特点是它维护了元素的顺序，即插入时...
【Datawhale AI 夏令营第三期学习笔记Taks1】 跑通baseline #Datawhale AI 夏令营
07-28
【Datawhale AI 夏令营第三期学习笔记Taks1】 跑通baseline #Datawhale AI 夏令营
餐厅营销策划方案.doc
07-28
商业计划书，创业计划书，项目计划书，计划书模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
OpenMv串口通信，接收数据
最新发布
07-28
OpenMV 是一个开源的机器视觉平台，它为嵌入式系统提供了强大的图像处理能力。OpenMV 主要面向对机器视觉有需求的开发者和爱好者，通过其强大的微控制器和摄像头模块，用户可以在低成本的前提下实现复杂的视觉任务。OpenMV 既可以用于教育领域，帮助学生理解图像处理和计算机视觉的基础知识，也可以用于工业应用，实现自动化检测、分类和导航等功能。 在 OpenMV 系统中，通信模块是实现与其他设备或系统互联互通的关键部分。OpenMV 支持多种通信协议，包括串口通信（UART）、I2C、SPI、CAN 和 USB 等。这些通信接口使得 OpenMV 可以方便地与各种传感器、执行器以及其他嵌入式设备进行数据交换，从而扩展其应用范围和功能。 串口通信（UART）是一种广泛应用于嵌入式系统的通信方式，具有实现简单、成本低廉的优点。OpenMV 的 UART 接口可以与单片机、PC 甚至其他 OpenMV 板卡进行数据传输，使得图像数据和处理结果能够及时传递给其他系统。这个是电赛智能送药小车利用openMv进行的串口通信接收数据的代码
【2021】新能源汽车简史：电动汽车沉浮录-Fastdata极数_62页.pdf
07-28
【2021】新能源汽车简史：电动汽车沉浮录-Fastdata极数_62页.pdf
java 中list
07-28
Java中的List是一种常用的集合类型，用于存储一组有序的元素。List接口继承自Collection接口，并且有多个实现类，比如ArrayList和LinkedList。\[1\] ArrayList是基于数组实现的，它的插入和查询操作效率较高，但是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值