精华内容
下载资源
问答
  • 2020-09-22 18:02:12
    import java.util.*;
    
    public class ListTest {
        public static void main(String[] args) {
            List<String> list =new ArrayList<>();
            list.add("a");
            list.add("b");
            list.add("c");
    
            /**
             * 第一种、最基础的遍历方式:for循环
             */
            for (int i=0;i<list.size();i++){
                System.out.println(list.get(i));
            }
    
    
            /**
             * 第二种、使用foreach遍历List
             */
            for (String a:list
                 ) {
                System.out.println(a);
            }
    
            /**
             * 第三种、适用迭代器Iterator遍历
             */
            Iterator<String> iterator =list.iterator();
            while (iterator.hasNext()){
                String next = iterator.next();
                System.out.println(next);
            }
    
            /**
             * 第四种、list.forEach JDK1.8 新特性
             */
                list.forEach(str -> System.out.println(str));
    
    
        }
    }
    

     

    更多相关内容
  • 初学Python,遇到过这样的问题,在遍历list的时候,删除符合条件的数据,可是总是报异常,代码如下: num_list = [1, 2, 3, 4, 5] print(num_list) for i in range(len(num_list)): if num_list[i] == 2: num_...
  • 在使用vuejs遍历数组的时候,使用in语句形式,会有一个警告的提示: 警告很明显说是少了v-bind:key,所以添加一个就ok了,看如下文件: /* eslint-disable */ (value,key,index) v-bind:key=key>//这里就可以...
  • list循环遍历remove的坑

    千次阅读 2022-02-09 17:36:32
    list循环遍历remove的坑

    清空一个list不借助于list自身的clear方法,使用for循环、foreach、Iterator来清空list。

    1、创建一个集合

    List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
    System.out.println("原始list:" + list);

    2.1、for循环正序遍历移除元素(遍历i要定义为int类型,list的remove方法参数为int时视为移除索引为i的元素,参数为Integer时视为移除元素等于i的元素)

    //正序遍历移除元素
    for (int i = 0; i < list.size(); i++) {
        list.remove(i);
    }
    System.out.println("for循环正序遍历移除元素结果:" + list);

    结果:运行正常,结果不符合预期

    原始list:[1, 2, 3, 4]
    for循环正序遍历移除元素结果:[2, 4]

    原因:for循环遍历移除list元素时,list内部结构也在发生变化,size在减小。

    当移除了一个元素1后,list变为[2,3,4],再次遍历删除第二个元素时,程序删除的是新list的第二个元素3,而不是我们期望的元素2。【漏删】

    当移除了两个元素后,判断条件 i=2, list.size()=2跳出循环。【未删除完成就跳出】

    代码没有按照预想移除所有元素。

    2.2、for循环倒序遍历移除元素

    //倒序遍历移除元素
    for (int i = list.size()-1; i >= 0 ; i--) {
        list.remove(i);
    }
    System.out.println("for循环倒序遍历移除元素结果:" + list);

    运行结果:运行正常,结果符合预期

     原始list:[1, 2, 3, 4]
    for循环倒序遍历移除元素结果:[]

    原因:每次删除list最后一个元素,就不会出现漏删元素、提前跳出循环的情况,且所有元素依次被删除。

    3.1、foreach循环移除元素

    for (Integer integer : list) {
        list.remove(integer);
    }
    System.out.println("foreach循环遍历移除元素结果:" + list);

    运行结果:运行失败,抛出异常:ConcurrentModificationException

    原始list:[1, 2, 3, 4]
    Exception in thread "main" java.util.ConcurrentModificationException
        at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
        at java.util.ArrayList$Itr.next(ArrayList.java:861)
        at Test.RemoveListTest.removeByForeach(RemoveListTest.java:33)
        at Test.RemoveListTest.main(RemoveListTest.java:13)

    原因:通过报错可以看出ArrayList类中Itr.checkForComodification方法报错,位置再911行(下边代码倒数第三行)

    看源码:

        /**
         * An optimized version of AbstractList.Itr
         */
        private class Itr implements Iterator<E> {
            int cursor;       // index of next element to return
            int lastRet = -1; // index of last element returned; -1 if no such
            int expectedModCount = modCount;
    
            Itr() {}
    
            public boolean hasNext() {
                return cursor != size;
            }
    
            @SuppressWarnings("unchecked")
            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);
                    cursor = lastRet;
                    lastRet = -1;
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException ex) {
                    throw new ConcurrentModificationException();
                }
            }
    
            @Override
            @SuppressWarnings("unchecked")
            public void forEachRemaining(Consumer<? super E> consumer) {
                Objects.requireNonNull(consumer);
                final int size = ArrayList.this.size;
                int i = cursor;
                if (i >= size) {
                    return;
                }
                final Object[] elementData = ArrayList.this.elementData;
                if (i >= elementData.length) {
                    throw new ConcurrentModificationException();
                }
                while (i != size && modCount == expectedModCount) {
                    consumer.accept((E) elementData[i++]);
                }
                // update once at end of iteration to reduce heap write traffic
                cursor = i;
                lastRet = i - 1;
                checkForComodification();
            }
    
            final void checkForComodification() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }
        }

    ArrayList内部重新实现Iterator迭代器的方法,并且添加了checkForComodification方法用来校验修改次数是否和预期值一致,调用迭代器的remove和next方法都用调用checkForComodification方法进行检测。

    checkForComodification方法:判断modCount与expectedModCount是否相等。

    modCount是AbstractList类的常量,add和remove操作都会使modCount + 1。

    expectedModCount值等于创建迭代器时modCount的值。

    使用迭代器进行循环遍历会调用next方法,第一次next后modCount值会+1,进行第二次遍历的时候,迭代器调用next方法,next调用checkForComodification方法时,发现modCount与expectedModCount值不相等,因此抛出异常。

    通过源码我们可以看出,迭代器内部实现的remove方法有重置expectedModCount值,因此我们可以使用迭代器内部的remove方法,而不是list自己的remove方法,来实现元素移除操作。

    3.2、foreach循环移除元素【修改】

    for (Iterator iterator = list.iterator(); iterator.hasNext();) {
        iterator.remove();
    }
    System.out.println("foreach循环遍历移除元素结果:" + list);

    运行结果:运行失败,抛出异常:IllegalStateException

    原始list:[1, 2, 3, 4]
    Exception in thread "main" java.lang.IllegalStateException
        at java.util.ArrayList$Itr.remove(ArrayList.java:874)
        at Test.RemoveListTest.removeByForeach(RemoveListTest.java:40)
        at Test.RemoveListTest.main(RemoveListTest.java:14)

    原因:从3.1中ArrayList中实现的迭代器源码可以看出,它还维护了类型为int的lastRet属性和cursor属性。

    cursor:返回next元素之后位置的索引,初始值为0。

    lastRet:返回next元素之前位置的索引,如果没有就返回-1,且给的默认值为-1。

    迭代器的remove方法,它会先判断lastRet是否小于0,是就抛出IllegalStateException异常。

    迭代器的next方法,返回cursor指向的元素,lastRet = cursor,cursor下移一位+1。

    直接调用remove方法时,lastRet值为-1,所以会抛出异常。

    我们可以先调用next方法,然后再调用remove方法就可以避免这种异常产生。

    3.3、foreach循环移除元素【修改plus】

    for (Iterator iterator = list.iterator(); iterator.hasNext();) {
        iterator.next();
        iterator.remove();
    }
    System.out.println("foreach循环遍历移除元素结果:" + list);

    运行结果:运行正常,结果符合预期

    原始list:[1, 2, 3, 4]
    foreach循环遍历移除元素结果:[]

    4、Iterator遍历移除元素

    Iterator<Integer> iterator = list.iterator();
    while (iterator.hasNext()){
        iterator.next();
        iterator.remove();
    }
    System.out.println("Iterator遍历移除元素结果:" + list);

    运行结果:运行正常,结果符合预期

    原始list:[1, 2, 3, 4]
    Iterator遍历移除元素结果:[]

    原因:原理同3.x一样。

    5、附上所有代码

    import java.util.*;
    
    public class RemoveListTest {
    
        public static void main(String[] args) {
            List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
            System.out.println("原始list:" + list);
            removeByFor(list);
    //        removeByForeach(list);
    //        removeByIterator(list);
    
    
        }
    
        private static void removeByFor(List<Integer> list) {
            //正序遍历移除元素。正常运行,不符合预期
    //        for (int i = 0; i < list.size(); i++) {
    //            list.remove(i);
    //        }
    //        System.out.println("for循环正序遍历移除元素结果:" + list);
            //倒序遍历移除元素。正常运行,符合预期
            for (int i = list.size()-1; i >= 0 ; i--) {
                list.remove(i);
            }
            System.out.println("for循环倒序遍历移除元素结果:" + list);
        }
    
        private static void removeByForeach(List<Integer> list) {
            //实际上调用ArrayList的内部foreach方法。抛出异常:ConcurrentModificationException
    //        for (Integer integer : list) {
    //            list.remove(integer);
    //        }
            //直接用迭代器的remove方法。抛出异常:IllegalStateException
    //        for (Iterator iterator = list.iterator(); iterator.hasNext();) {
    //            iterator.remove();
    //        }
    
            //先调用next方法,再调用remove方法,避免IllegalStateException异常的产生
            for (Iterator iterator = list.iterator(); iterator.hasNext();) {
                iterator.next();
                iterator.remove();
            }
            System.out.println("foreach循环遍历移除元素结果:" + list);
        }
    
        private static void removeByIterator(List<Integer> list) {
            Iterator<Integer> iterator = list.iterator();
            while (iterator.hasNext()){
                iterator.next();
                iterator.remove();
            }
            System.out.println("Iterator遍历移除元素结果:" + list);
        }
    }

    展开全文
  • List集合循环遍历

    千次阅读 2022-01-13 10:10:57
    1.增强for循环遍历 2.一般for循环遍历 3.迭代器循环遍历 package com.jpa.demo; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Testssss { public static void...

    1.增强for循环遍历
    2.一般for循环遍历
    3.迭代器循环遍历

    package com.jpa.demo;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class Testssss {
    
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("java");
            list.add("c#");
            list.add("python");
            traversalList1(list);
            traversalList2(list);
            traversalList3(list);
        }
    
        /** 1.比较常用:增强for循环 */
        static void traversalList1(List<String> list){
            for (String str:list) {
                System.out.println(str);
            }
        }
    
        /** 2.一般far循环 */
        static void traversalList2(List<String> list){
            for (int i=0; i<list.size(); i++){
                System.out.println(list.get(i));
            }
        }
    
        /** 3.迭代器遍历 */
        static void traversalList3(List<String> list){
            Iterator<String> iterator = list.iterator();
            while (iterator.hasNext()){
                //注意不要在一次循环中 多次调用 iterator.next()
                String next = iterator.next();
                System.out.println(next);
    
                //错误示范:
    //            System.out.println(iterator.next());
    //            System.out.println(iterator.next());
            }
        }
    
    }
    
    
    展开全文
  • 从c/c++语言转向java开发,学习java语言list遍历的三种方法,顺便测试各种遍历方法的性能,测试方法为在ArrayList中插入1千万条记录,然后遍历ArrayList,发现了一个奇怪的现象,测试代码例如以下: package ...
  • 最有效的方法: public class Test { public static void main(String args[]){ List list = new ArrayList(); list.add("a"); list.add("b"); list.add("b"); list.add("c")

    最有效的方法:

    public class Test {
        public static void main(String args[]){
            List<String> list = new ArrayList<String>();
            list.add("a");
            list.add("b");
            list.add("b");
            list.add("c");
            list.add("b");
            Iterator<String> iter = list.iterator();
            while(iter.hasNext()){
                String s = iter.next();
                if(s.equals("b")){
                    iter.remove();
                }
            }
            System.out.println(list);
        }
    }

    输出:

    [a, c]


    其他两种方法虽然可以删除,但是会有bug:

    方法一:

    public class Test {
        public static void main(String args[]){
            List<String> list = new ArrayList<>();
            list.add("a");
            list.add("b");
            list.add("b");
            list.add("c");
            list.add("c");
            list.add("b");
            for(int i=0;i<list.size();i++){
                if(list.get(i).equals("b")){
                    list.remove(i);
                }
            }
            System.out.println(list);
        }
    }
    输出:

    [a, b, c, c]

    原因:当i=1时候,list删除掉一项,此时list.size()=5,下一个循环i=2,此时size为5的list为[a,b,c,c,b],i=2是list.get(2)=“c”,所以有一个b被忽略掉啦。’


    方法二:

    public class Test {
        public static void main(String args[]) {
            List<String> list = new ArrayList<>();
            list.add("a");
            list.add("b");
            list.add("b");
            list.add("c");
            list.add("c");
            for (String s : list) {
                if (s.equals("b")) {
                    list.remove(s);
                }
            }
            System.out.println(list);
        }
    }
    报错:

    Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
    at java.util.ArrayList$Itr.next(ArrayList.java:851)
    at com.chinook5.util.Test.main(Test.java:17)

    这是由于增强for循环底层调用的是迭代器的next和hasnext方法来遍历的,移除元素后,无法预知到元素的位置。这也是增强for的缺点,不能获取下标,不能动态删除集合中的内容。

    改进:

    public class Test {
        public static void main(String args[]) {
            List<String> list = new ArrayList<String>();
            list.add("a");
            list.add("b");
            list.add("b");
            list.add("c");
            list.add("b");
            List<String> list_remove = new ArrayList<String>();
            for(String s : list){
                if("b".equals(s)){
                    list_remove.add(s); //把要移除的统一放在一个集合
                }
            }
            //统一移除
            list.removeAll(list_remove);
            System.out.println(list);
        }
    }

    输出:[a,c]

    展开全文
  • 转自:https://blog.csdn.net/changjizhi1212/article/details/81036509JAVA中循环遍历list有三种方式for循环、增强...1、for循环遍历listfor(int i=;iif(list.get(i).equals("del"))list.remove(i);}这种方式的问...
  • List集合的循环遍历方式

    千次阅读 2020-01-19 15:27:43
    List集合的特点: 有序 【存入 取出 元素顺序一致】 可重复 【判断重复的条件equals 如果是系统类型则无需重写equals方法 如果是自定义的...List集合的三种遍历方式: // 创建一个ArrayList集合 我就用ArrayLis...
  • 下面小编就为大家带来一篇java中循环遍历删除List和Set集合中元素的方法(推荐)。小编觉得挺不错的,在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • python怎么循环遍历list

    2020-11-25 12:00:57
    可以使用for循环遍历list为了更有效率的输出列表的每个数据,可以使用循环来完成示例:In [3]: list1=["zhang","qing","123",123,"zhang123"In [4]: for temp in list1:...: print("遍历list1=%s"%temp)遍历list1=...
  • 主要介绍了PHP循环遍历数组的3种方法list()、each()和while总结,本文重点在于对这3种方法的混合使用讲解上,需要的朋友可以参考下
  • List中的三种循环遍历及删除操作

    千次阅读 2021-07-15 18:00:56
    1、for循环遍历list public static void main(String[] args) { List list = new ArrayList(); list.add("asdf"); list.add("我多想"); list.add("我多想"); list.add("一少年"); list.add(1); System....
  • Thymeleaf是一个很好用的模板引擎, 可以完全取代JSP 需求 数据库中有张名为commanders的表存有多个人的信息, 现在通过后台去查询整张表, 返回一个集合... @RequestMapping("/list") public String queryAll(Map map) {
  • 在日常代码中,遍历List然后删除特定的元素是很常见的操作,Java中的循环主要有普通的for循环、增加for循环、iterator遍历这几种方法,我们知道在循环list时删除元素可能引起异常,这里总结下什么情况下会引起异常,...
  • java中List遍历方法

    2021-06-23 11:03:33
    在做实验写代码时,List集合的遍历是经常要用到的 经过课上的讲解与课后的相关学习,总结如下: 首先在遍历之前创造一个List如下: ...第一种方法:for循环遍历 理解起来最为简单,利...
  • 如下所示: a = [1, 2, 3, 8, 9] ...以上这篇在Python中,不用while和for循环遍历列表的实例就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持软件开发网。 您可能感兴趣的文章:pytho
  • 主要介绍了详解Java中list,set,map的遍历与增强for循环的相关资料,需要的朋友可以参考下
  • 主要介绍了python 双循环遍历list 变量判断代码,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Python for循环可以遍历任何序列的项目,如一个列表或者一个字符串。 语法: for 临时变量 in 序列: 重复执⾏的代码1 重复执⾏的代码2 基础版 name_list = ['jack', 'tom', 'tony', 'rose'] for i in name_list: ...
  • 【JAVA】easypoi根据Excel模板导出 循环遍历合并单元格处理
  • for循环遍历List的两种方法

    千次阅读 2021-08-21 18:10:07
    Java中for循环遍历List的两种方法 常用的方法: List<Person> people = ...; for (int 1=0;i<people.size();i++){ people.get(i).setEat("吃饭"); } 相当于: List<Person> people = ...; ...
  • 遍历list的时候,删除符合...原因是在删除list中的元素后,list的实际长度变小了,但是循环次数没有减少,依然按照原来list的长度进行遍历,所以会造成索引溢出。 解决方案:倒序循环删除 num_list = [1, 2, 3, 4,
  • python list 列表遍历的4种方法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 354,772
精华内容 141,908
关键字:

list循环遍历