ArrayList和LinkedList的三种遍历方式

最新推荐文章于 2022-11-04 11:00:01 发布
置顶 最新推荐文章于 2022-11-04 11:00:01 发布
阅读量903 收藏 4
点赞数 1
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/programmerylj/article/details/107550476
版权

一.三种List遍历性能比较

List的遍历方式多样，那该怎么去选择呢？怎么去衡量，性能是爹，当然是性能说了算啊，下面就写个简易的程序简单测试一下。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        final int n = 100;
        ArrayList<Integer> arrayList = new ArrayList<Integer>(n);
        LinkedList<Integer> linkedList = new LinkedList<Integer>();
        for (int i = 0; i < n; i++) {
            arrayList.add(i);
            linkedList.add(i);
        }

        double begin, end, time;
        int temp;

        begin = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            temp = arrayList.get(i);
        }
        end = System.currentTimeMillis();
        time = end - begin;
        System.out.println("ArrayList--大小" + n + "--for:" + time);

        begin = System.currentTimeMillis();
        for (Integer integer : arrayList)
            temp = integer;
        end = System.currentTimeMillis();
        time = end - begin;
        System.out.println("ArrayList--大小" + n + "--foreach:" + time);

        begin = System.currentTimeMillis();
        Iterator<Integer> iterator = arrayList.iterator();
        while (iterator.hasNext())
            temp = iterator.next();
        end = System.currentTimeMillis();
        time = end - begin;
        System.out.println("ArrayList--大小" + n + "--iterator:" + time);

        //--------------------------------------------------------//

        System.out.println("--------------------------------------");
        begin = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            temp = linkedList.get(i);
        }
        end = System.currentTimeMillis();
        time = end - begin;
        System.out.println("LinkedList--大小" + n + "--for:" + time);

        begin = System.currentTimeMillis();
        for (Integer integer : linkedList)
            temp = integer;
        end = System.currentTimeMillis();
        time = end - begin;
        System.out.println("LinkedList--大小" + n + "--foreach:" + time);

        begin = System.currentTimeMillis();
        Iterator<Integer> iterator1 = linkedList.iterator();
        while (iterator1.hasNext())
            temp = iterator1.next();
        end = System.currentTimeMillis();
        time = end - begin;
        System.out.println("LinkedList--大小" + n + "--iterator:" + time);

    }
}

输出结果：

1000条数据
ArrayList–大小1000–for:0.0
ArrayList–大小1000–foreach:1.0
ArrayList–大小1000–iterator:0.0
--------------------------------------
LinkedList–大小1000–for:2.0
LinkedList–大小1000–foreach:1.0
LinkedList–大小1000–iterator:0.0

100000条数据
ArrayList–大小100000–for:2.0
ArrayList–大小100000–foreach:2.0
ArrayList–大小100000–iterator:5.0
·--------------------------------------
LinkedList–大小100000–for:4951.0
LinkedList–大小100000–foreach:6.0
LinkedList–大小100000–iterator:1.0

把数据做个记录

ArrayList1001,00010,000100,0001,000,000
for0.00.01.01.08.0
foreach0.00.02.02.012.0
iterator0.00.01.01.011.0
LinkedList1001,00010,000100,0001,000,000
for0.01.049.04954.0很久
foreach0.00.01.07.022.0
iterator0.00.01.01.020.0

以上数据没有实验多次取平均值，有一些误差，但是，整体上可以看出在数据量比较小时，不同遍历方式的性能差别不大，但是在数据量比较大时，对于ArrayList来说，3钟遍历方式差距不是很大，其中for循环的效率最高，因为采用直接的下标运算，而对于LinkedList来说，迭代器效率最高，因为其相当于维护一个当前状态指针，遍历只需要扫描一遍双向链表即可，而for效率最低，因为需要扫描n遍链表，不难看出，两种List中，foreach的效率都比迭代器略低，因为其底层就是由迭代器实现的，只不过为了方便书写，做了简单的封装。

二.三种遍历List的方式底层分析

遍历List需要输出List的全部信息，其时间的消耗占比还是很大的，所以，选择正确的遍历方式非常重要，Java提供了三种遍历List的方式，下面我们来一一认识他们。

2.1 for循环

for循环是通过get(i)实现的，对于ArrayList来说，其实就是下标访问，时间复杂度为O（n），对于ArrayList来说，其底层是双向链表，每次都要从链表头或者表尾去遍历，具体是从头开始还是从尾开始取决于更靠近谁，所以其复杂度是指数级别的。
如果对ArrayList和LinkedList底层原理还不是很熟悉的可以查看这篇文章ArrayList和LinkedList的底层分析和比较

书写格式

        for (int i = 0; i < n; i++) {
            temp = arrayList.get(i);
        }

2.2 Iterator

首先分析一下ArrayList中迭代器的源码

    public Iterator<E> iterator() {
        return new Itr();//通过内部类实现
    }

    private class Itr implements Iterator<E> {
		int cursor;       // 下一个要访问元素的下标
        int lastRet = -1; // 上一个访问元素的下标
        int expectedModCount = modCount;

		public boolean hasNext() {//判断是否还有元素
            return cursor != size;
        }
        
		//返回下一个元素
		public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

//遍历过程中删除元素
		public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);//调用ArrayList的remove方法删除的上一个访问过的元素
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;//重新设置modCount，因为ArrayList.remove修改了这个值
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
}

从源码可知，ArrayList的迭代器方式遍历本质上也是通过下标访问，只不过具体步骤封装起来麻烦了一点。迭代器里面有个remove方法，能够动态的修改modCount，所以在遍历时删除元素也不会抛出异常，需要注意的一点是其删除的元素是上一个访问过的元素。

下面再看一下LinkedList的源码

 public boolean hasNext() {
            return nextIndex < size;
        }

        public E next() {
            checkForComodification();
            if (!hasNext())
                throw new NoSuchElementException();

            lastReturned = next;//更新上次返回的指针
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }

通过内部类ListItr的源码可知，LinkedList的迭代器维护一个当前访问的数据的指针，找下一个元素把指针指向next即可，所以速度很快。

书写格式

        Iterator<Integer> iterator = linkedList.iterator();
        while(iterator.hasNext())
            temp=iterator.next();

2.3 for each

先写一个建议简易代码，然后反编译查看其底层原理

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList=new ArrayList<>();
        arrayList.add(1);
        int temp;
        for(Integer integer:arrayList)
        {
            temp=integer;
        }
    }
}

反编译

D:\Document\java\algorithm\src>javac Main.java
D:\Document\java\algorithm\src>javap -c Main.class
Compiled from "Main.java"
public class Main {
  public Main();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #7                  // class java/util/ArrayList
       3: dup
       4: invokespecial #9                  // Method java/util/ArrayList."<init>":()V
       7: astore_1
       8: aload_1
       9: iconst_1
      10: invokestatic  #10                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      13: invokevirtual #16                 // Method java/util/ArrayList.add:(Ljava/lang/Object;)Z
      16: pop
      17: aload_1
      18: invokevirtual #20                 // Method java/util/ArrayList.iterator:()Ljava/util/Iterator;
      21: astore_3
      22: aload_3
      23: invokeinterface #24,  1           // InterfaceMethod java/util/Iterator.hasNext:()Z
      28: ifeq          51
      31: aload_3
      32: invokeinterface #30,  1           // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
      37: checkcast     #11                 // class java/lang/Integer
      40: astore        4
      42: aload         4
      44: invokevirtual #34                 // Method java/lang/Integer.intValue:()I
      47: istore_2
      48: goto          22
      51: return
}

什么底层语言看不懂，问题不大，我们把class文件拖入idea可以更方便的反编译

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
    public Main() {
    }

    public static void main(String[] var0) {
        ArrayList var1 = new ArrayList();
        var1.add(1);

        int var2;
        Integer var4;
        for(Iterator var3 = var1.iterator(); var3.hasNext(); var2 = var4) {
            var4 = (Integer)var3.next();
        }

    }
}

通过反编译，我们可以看到，foreach底层其实也是通过迭代器实现的，只不过用foeach更为方便。

三.遍历中能删除元素么

刚刚讨论了三种遍历方式的性能比较，对于遍历方式的选择大家心中也有了一杆明明白白的称，但是，在开发过程中，往往在遍历时需要删除元素，那遍历时，可以删除元素么？

3.1普通的for循环

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList=new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(2);
        arrayList.add(4);
        for(int i=0;i<arrayList.size();i++)
        {
            if(arrayList.get(i)==2)
            {
                arrayList.remove(i);
                //i--;下标没有-1会导致一些相同的元素没有被删除掉
                //下标-1后正确输出1 4
            }
        }
        for(int i=0;i<arrayList.size();i++)
        {
            System.out.println(arrayList.get(i));
        }
    }
}

输出结果为1 2 4；但是预期输出结果为1 4；出现这种情况是因为删除后直接把后面的元素前移了，而i如果没有-1，那么就会漏掉一些元素的比较。LinkedList结果也和上面一样，需要把i-1才能得到正确结果。

3.2 迭代器Iterator

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList=new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(2);
        arrayList.add(4);

        Iterator<Integer> iterator = arrayList.iterator();
        while(iterator.hasNext())
        {
            if (iterator.next()==2)
                iterator.remove();
        }

        for(int i=0;i<arrayList.size();i++)
        {
            System.out.println(arrayList.get(i));
        }

    }
}

输出1 4，符合我们的预测，推荐使用。需要注意的是，删除用的是iterator的remove方法，由上期《ArrayList和LinkedList的底层分析和比较》 源码分析可以知道，迭代器的remove方法是先调用list的remove方法删除元素并且修改modCount,然后remove方法里会更新modCount实现，如果我们直接调用list的remove方法去删除元素，会导致迭代器里面记录的modCount和预期值不同而抛出ConcurrentModificationException异常。

3.3 for each

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList=new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);

    for(Integer integer:arrayList)
    {
        if(integer==2)
            arrayList.remove(integer);
    }

        for(int i=0;i<arrayList.size();i++)
        {
            System.out.println(arrayList.get(i));
        }

    }
}

会抛出ConcurrentModificationException异常，至于为什么会抛出异常，反编译一下就可以知道原理了

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
    public Main() {
    }

    public static void main(String[] var0) {
        ArrayList var1 = new ArrayList();
        var1.add(1);
        var1.add(2);
        var1.add(3);
        var1.add(4);
        Iterator var2 = var1.iterator();

        while(var2.hasNext()) {
            Integer var3 = (Integer)var2.next();
            if (var3 == 2) {
                var1.remove(var3);//相当于调用了直接调用了List的remove方法
            }
        }

        for(int var4 = 0; var4 < var1.size(); ++var4) {
            System.out.println(var1.get(var4));
        }

    }
}

反编译可以知道，foreach删除元素时，调用了List的remove方法，直接导致itetator记录的modCount和预期值不同，于是抛出异常。

总结一下，iterator遍历时删除元素没有那么多限制，推荐使用，简单for循环遍历时需要把脚标-1，不然会导致一些元素没有比较，foreach内部用iterator遍历，但是调用list的remove方法，会抛出异常，不推荐使用。

做一件短期没有回报的事很容易使人陷入迷茫的境遇，但是，能坚持下来的一定是个成功者！！！

程序猿之家
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java用多种方法遍历 ArrayList、LinkedList、Vector集合
baolingye的博客
05-09 437
Java用多种方法遍历 ArrayList、LinkedList、Vector集合 先自定义一个Student类，包含姓名、年龄 public class Student { private String name; private int age; public Student() { } public Student(String name, int...
（2）美团试题：ArrayList和linkedlist有什么区别，如何遍历，使用for循环遍历linkedlist为什么效率低，linkedlist能使用索引访问么，使用迭代器呢
王伟的博客
09-09 7400
（一）ArrayList和linkedlist有什么区别？ 简单的区别： 1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 （LinkedList是双向链表，有next也有previous） 2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。 3....
java集合基础的整理，方法与测试 之 ArrayList与LinkedList 存储 插入 遍历时间比较与解释（干货）（二）
qq_45020715的博客
12-15 262
ArrayList与LinkedList 存储 插入 遍历时间比较与解释 知识提示： Java中ArrayList使用数组实现的。 LinkedList的使用双向链表实现的。 对于这两种数据结构。数组：遍历快，插入，删除慢。链表：遍历慢，插入，删除慢。若想详细了解集合的其他基础知识建议参考：集合干货 下面开始今天的分享（瞎扯），???? 1.分别创建ArrayList和LinkedList集合。 Li...
解析ArrayList与LinkedList的遍历方法
weixin_30621959的博客
07-31 93
ArrayList与LinkedList都是实现List接口，前者底层是数据存储，而LinkedList则是以链表的形式存储，因此两个都各有其独自的特性。在两者中，遍历方法也随着改变而有所不同。 遍历方法 通用的List的遍历方法有三种： 1、for get循环遍历 2、foreach遍历 3、for Iterator迭代遍历 遍历结果 arrayList length: 360000 linke...
List、LinkedList、ArrayList集合存储学生对象三种遍历方式
code猫大叔
11-04 461
这个案例，很实用
Java中ArrayList和LinkedList的遍历与性能分析
09-01
在Java编程中，ArrayList和LinkedList是两种常用的列表（List）实现，它们各有特点，并且在遍历和性能上有显著的差异。以下是对这两种数据结构及其遍历方式的详细分析： 1. **ArrayList**：ArrayList是基于动态数组...
Java中ArrayList和LinkedList区别
12-22
在Java编程语言中，ArrayList和LinkedList都是集合框架中两种重要的列表实现，它们分别基于不同的数据结构，具有不同的特性和性能特点。以下是对这两个类的详细分析： 1. 数据结构： - ArrayList是基于动态数组的...
对ArrayList和LinkedList底层实现原理详解
08-26
总结：ArrayList 和 LinkedList 是 Java 中两个常用的集合类，它们的底层实现方式不同，ArrayList 是基于数组实现的，而 LinkedList 是基于链表实现的。理解它们的底层实现方式可以帮助我们更好地使用它们。
java 集合之实现类ArrayList和LinkedList的方法
08-29
Java 集合框架中，ArrayList 和 LinkedList 是两种常用的实现类，分别实现了 List 接口。下面我们将详细介绍这两种实现类的方法。 ArrayList ArrayList 是一个基于数组实现的 List 接口实现类，它的底层是使用数组...
ArrayList和Linkedlist1
08-08
在IT领域，特别是Java编程中，ArrayList和LinkedList是两种非常重要的数据结构，它们都是List接口的实现类。理解这两者的区别对于优化程序性能至关重要。面试官询问这些知识点，旨在评估应聘者的理论基础和实践能力...
Java 集合基础
weixin_52795571的博客
03-20 454
Java 集合基础 1.集合基础 1.1集合概述 编程的时候如果要存储多个数据，使用长度固定的数组存储格式，不一定满足我们的需求，更适应不了变化的需求，要是想要长度可以变化的存储格式，数组就不行了，这个时候就需要集合 集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变 集合： Collection接口（单列集合） List接口（元素内容可重复） ArrayList（实现类） LinkedList（实现类） … Set接口（元素内容不可重复） HashSet（实现类） Tre
上机实验6 集合案例
qq_64314976的博客
07-18 1587
现有班级学生5人，姓名分别是zhangsan、lisi、tom，jack、mick，又转来一名学生，姓名为zhangsan。将学生姓名存储到ArrayList集合、HashSet集合、TreeSet集合，采用普通for循环、增强for循环、Iterator迭代器等方法分别对集合信息遍历输出。分别使用List、set集合和Map存放多个图书信息，遍历并输出。编写程序，分别使用List、set集合存放学生的姓名，遍历并输出。将图书id作为键，图书对象作为值，实现Map集合存储数据。ArrayList集合。...
ArrayList与LinkedList遍历方式对比及List遍历技巧
itigoitie的博客
05-18 589
ArrayList与LinkedList遍历方式对比及List遍历技巧ArrayList遍历方式for loopfor-each loopIteratorListIteratorjava8新特性：forEachArrayList遍历方式分析LinkedList遍历方式for loopfor-each loopIteratorListIteratorjava8新特性：forEachLinkedList遍历方式分析List遍历技巧 ArrayList遍历方式 首先在主函数中调用ArrayList的构造方法生成一
Java基础 （三）：LinkedList（含使用方法详解）
热门推荐
Viper的程序员修炼手册
07-20 1万+
Java LinkedList 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。 链表可分为单向链表和双向链表。 一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。 一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。 Java LinkedList（链表） 类似于 ArrayList，是一种常用的数据容器。 与 ArrayList 相比，LinkedList 的增加和删除对操作效
【数据结构】使用Java实现顺序表类 SeqList
qq_41427568的博客
04-17 6460
目录线性表介绍顺序表介绍Java->顺序表APIJava->顺序表代码 线性表介绍 数据结构中的线性存储结构分为两大类：顺序存储和链式存储，顺序存储对应的是顺序表，链式存储对应的是链表。这篇文章主要介绍如何使用Java实现一个顺序表。 顺序表介绍 顺序表： 把线性表的元素按照一定逻辑顺序依次放在一组地址连续的存储单元里，用这种方式存储的线性表简称为 顺序表。而链表中的元素是没有放在一组...
LinkedList 的所有遍历方式
maocalm的博客
07-29 3290
package com.nine;import java.util.Iterator; import java.util.LinkedList;public class Test { public static void main(String[] args) { LinkedList linkedList = new LinkedList(); linked
java linklist 遍历_Java LinkedList遍历的7种方法
weixin_35523135的博客
02-16 1748
首页>基础教程>集合框架>LinkedList类Java LinkedList遍历的7种方法LinkedList遍历方法1. 一般的for循环(随机访问)遍历int size = list.size();for (int i=0; ilist.get(i);}2. for--each循环遍历for (Integer integ:list){;}3. 迭代器iterat...
LinkedList的listIterator()方法，详细举例
喝泉水的泉
11-11 1693
LIinkedList的listiterator方法对于初学者来说，真的很容易搞错。 LinkedList调用listiterrator方法后返回的是ListIterator类型的迭代器，这个类是Iterator的子类，你会发现这个子类中是有add方法的，而超类没有。 为什么呢？ 很简单，因为对有序的集合使用迭代器添加元素才有实际意义。但java集合类库提供了子接口ListIterator，它有add方法，然后我们就可以根据迭代器的定位来添加元素了。 如果理论看不懂文字解释，也无所谓，下面的方法，包
Java中关于ArrayList和LinkedList遍历效率
weixin_34356555的博客
01-05 2871
Java中经常会使用List进行遍历，随着数据量不断增大，遍历很大数据的时候，发现执行效率炸了，灰常慢，翻了日志，发现在遍历数据List中巨慢，一直在循环。查了下资料，测试了下两种LinkedList,ArrayList方式。开始遍历100万条数据，分别使用迭代器Iterator,foreach,for方式进行遍历。首先对LinkedList进行三种方式遍历.结果如下：此时会发现foreach和迭...
arraylist和linkedlist遍历
最新发布
04-12
ArrayList和LinkedList都是可用于存储数据的集合类，但它们的遍历方式略有不同。ArrayList是通过索引顺序读取元素，而LinkedList则是通过链表的方式遍历元素。因此，当涉及到需要随机访问、删除、添加元素时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值