精华内容
下载资源
问答
  • list集合删除
    2022-01-13 10:23:01

    使用迭代器删除集合元素,不要在循环中使用list.remove()去删除

    代码实现

    package com.jpa.demo;
    
    import com.alibaba.fastjson.JSON;
    
    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");
            deleteListElement(list);
            System.out.println(JSON.toJSON(list));
        }
    
        static void deleteListElement(List<String> list){
            Iterator<String> iterator = list.iterator();
            while (iterator.hasNext()){
                String next = iterator.next();
                if ("java".equals(next)) {
                    iterator.remove();
                }
            }
        }
    
    }
    
    
    更多相关内容
  • List集合删除元素的正确姿势

    万次阅读 2018-06-18 16:14:40
    作为Java大家庭中的集合类框架,List应该是平时开发中最常用的,可能有这种需求,当集合中的某些元素符合一定条件时,想要删除这个元素。如:[java] view plain copy print?public&amp;nbsp;class&amp;nbsp;...

    在阅读阿里巴巴规约的时候发现有一条规约是关于List的【不要在foreach里面进行元素的remove/add操作,remove请使用Iterator方式】。然后想起以前自己做项目的时候删除某一元素的逻辑报下标越界错误,那时候记得处理是用一新的List进行存储,然后整体从原List移除所有符合规则的元素,现在做一总结。用这个Iterator主要可以避免下标越界或者遍历是漏掉符合规则的下一个数据。

    先拉出来正确删除元素的姿势。正确姿势是利用Iterator的remove方法。具体操作如下:

    public static void main(String[] args) {
            List<Integer> lists = new ArrayList<Integer>();
            lists.add(1);
            lists.add(2);
            lists.add(3);
            lists.add(4);
            lists.add(5);
            Iterator<Integer> iterator = lists.iterator();
            while (iterator.hasNext()){
                Integer obj = iterator.next();
                if(3==obj || 4==obj){
                    iterator.remove();
                }
            }
            System.out.println(lists);
    
        }

    附上自己比较笨的操作方式:

    public static void main(String[] args){
                List<Integer> lists = new ArrayList<Integer>();
                List<Integer> listscopy = new ArrayList<>();
                lists.add(1);
                lists.add(2);
                lists.add(3);
                lists.add(4);
                lists.add(5);
                int size = lists.size();
                for (int i = 0; i < lists.size(); i++) {
                    if(3==lists.get(i) || 4 == lists.get(i)){
                        listscopy.add(lists.get(i));
                    }
                }
                lists.removeAll(listscopy);
                System.out.println(lists);
    
            }

    然后常用的错误方式有以下三种:
    第一种方式,多出现下标越界问题。这个主要原因是因为我们在循环遍历时,将我们的长度进行定值确定。而忽略掉在满足条件时,list的长度是减少的。

    public static void main(String[] args) {
     List<Integer> lists = new ArrayList<Integer>();
            lists.add(1);
            lists.add(2);
            lists.add(3);
            lists.add(4);
            lists.add(5);
            int size = lists.size();  // 定长设置,会造成元素下标越界,如果将for中变量直接换成lists.size()可以吗?
            for (int i = 0; i < size; i++) {
                if(3==lists.get(i) || 4 == lists.get(i)){
                    lists.remove(i); //lists.remove(lists.get(i));
                }
            }
            System.out.println(lists);
     }

    第二种方式也就是上面的注释所说,既然会出现下标越界,那我就利用动态的大小不就可以了,但是利用这种方法会产生另外一种情况,就是会忽略掉remove元素后面的一个元素,这个是因为删除符合规则的元素后,list长度减一,而同时后面的元素往前补一位,造成当前i值下对应两个元素。

    public static void main(String[] args) {
            List<Integer> lists = new ArrayList<Integer>();
            lists.add(1);
            lists.add(2);
            lists.add(3);
            lists.add(4);
            lists.add(5);
            int size = lists.size();
            for (int i = 0; i < lists.size(); i++) {
                if(3==lists.get(i) || 4 == lists.get(i)){
                    lists.remove(i); //lists.remove(lists.get(i));
                }
            }
            System.out.println(lists); // 打印[1, 2, 4, 5] 此时会将4忽略掉
        }

    第三种方式是利用增强FOR循环造成的。这种方式会直接给报错:

    ERRORInfo:
    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)
    
    
    public static void main(String[] args) {
            List<Integer> lists = new ArrayList<Integer>();
            lists.add(1);
            lists.add(2);
            lists.add(3);
            lists.add(4);
            lists.add(5);
           for (Integer i : lists){
               if(3==i || 4==i){
                   lists.remove(i);
               }
           }
            System.out.println(lists);
        }

    这种情况下。主要是集合遍历是使用Iterator, Iterator是工作在一个独立的线程中,并且拥有一个互斥锁。Iterator 被创建之后会建立一个指向原来对象的单链索引表,当原来的对象数量发生变化时,这个索引表的内容不会同步改变,所以当索引指针往后移动的时候就找不到要迭代的对象,所以按照 fail-fast原则 Iterator 会马上抛出java.util.ConcurrentModificationException 异常。所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。

    【 文章有查询:高爽|Coder,原文地址:http://blog.csdn.net/ghsau/article/details/9347357。】

    展开全文
  • list集合删除某个元素值相同的对象

    千次阅读 2020-07-25 15:21:35
    实体类User 有三个属性:id name age ...比如说下方数据,我要去除list中user对象id为i的数据,只留下一个。 public static void main(String[] args) { User user = new User(); user.setId(1);

    实体类User 有三个属性:id name age

    public class User {
        private Integer id;
        private String name;
        private Integer age;
    }
    

    比如说下方数据,我要去除list中user对象id为i的数据,只留下一个。

    	 public static void main(String[] args) {
    		User user = new User();
            user.setId(1);
            user.setName("小四");
            user.setAge(24);
            User user1 = new User();
            user1.setId(2);
            user1.setName("小五");
            user1.setAge(25);
            User user2 = new User();
            user2.setId(1);
            user2.setName("小六");
            user2.setAge(26);
            List<User> users = new ArrayList<>();
            users.add(user);
            users.add(user1);
            users.add(user2);
            
    		HashMap<Integer, User> tempMap = new HashMap<>();
            // 去掉重复的key
            for (User userInfo : users) {
                Integer id = userInfo.getId();
                // containsValue(Object value)该方法判断Map集合中是否包含指定的键值,如果包含返回true,不包含返回false
                if (tempMap.containsKey(id)) {
                    User newUser = new User();
                    newUser.setId(id);
                    // 合并相同key的value
                    newUser.setName(tempMap.get(id).getName());
                    newUser.setAge(tempMap.get(id).getAge());
                    // HashMap不允许key重复,当有key重复时,前面key对应的value值会被覆盖
                    tempMap.put(id, newUser);
                } else {
                    tempMap.put(id, userInfo);
                }
            }
            List<User> newList = new ArrayList<>();
            Iterator iter = tempMap.entrySet().iterator();
            while (iter.hasNext()) {
                Map.Entry entry = (Map.Entry) iter.next();
                User newUser = (User) entry.getValue();
                newList.add(newUser);
            }
    
            System.out.println("newList====" + newList);
        }
    

    运行main方法结果是:
    在这里插入图片描述
    可以看到小六的数据没有了,因为它和小四的id一样,同为1,所以被去除了。

    那么下面问题来了,我想要小六的数据咋办,很简单,只需要在这个位置就能对重复值的数据进行处理,如果我把小四、小六数据结果相加:

    在这里插入图片描述
    这样子输出结果就是这样的:
    在这里插入图片描述
    在实际开发过程中可以根据实际情况进行数据的处理。

    展开全文
  • List集合删除元素的正确姿态

    千次阅读 2020-05-03 21:47:28
    在遍历集合的时候,我们可能会根据业务的需要而需要排除集合的一些元素,通常我们遍历List集合常用的有下列3种方式: 1.普通for循环 for(int i= 0; i<list.size(); i++) { } 2.增强for for(int i : list){ }...
    一、集合元素遍历

    在遍历集合的时候,我们可能会根据业务的需要而需要排除集合的一些元素,通常我们遍历List集合常用的有下列3种方式:

    1.普通for循环

    
    forint i= 0; i<list.size(); i++) {
    }
    

    2.增强for

    forint i : list){
    }
    

    3.迭代器

    Iterator <Integer> iterator = list.iterator();
    while (iterator.hasNext()){}
    

    二、集合元素的删除

    综合上面三种方式测试删除,代码如下:

     @Test
        public void test3(){
    
            try {
                delete1();
            }catch (Exception e){
                log.info("delete1 方法遍历删除出现异常,异常类型是{}",e.getClass().getSimpleName());
            }
            try {
                delete2();
            }catch (Exception e){
                log.info("delete2 方法遍历删除出现异常,异常类型是{}",e.getClass().getSimpleName());
            }
            try {
                delete3();
            }catch (Exception e){
                log.info("delete3 方法遍历删除出现异常,异常类型是{}",e.getClass().getSimpleName());
            }
    
        } 
        // 初始化一个list 
        public List<Integer> init(){
            List<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            list.add(4);
            list.add(5);
            return  list;
        }
        // 普通for循环删除
        public <T> void  delete1(){
            List<Integer> list = init();
            for (int i = 0; i < list.size(); i++) {
                if (list.get(i).equals(3)){
                    list.remove(i);
                }
            }
    
            log.info("delete1 方法执行成功");
        }
    	// 迭代器删除
        public void  delete2(){
            List<Integer> list = init();
            Iterator <Integer> iterator = list.iterator();
            while (iterator.hasNext()){
                Integer next = iterator.next();
                if (next.equals(3)) {
                    iterator.remove();
                }
            }
            log.info("delete2 方法执行成功");
        }
        // 增强for循环
        public  void  delete3(){
            List<Integer> list = init();
            for (Integer t : list) {
                if (t.equals(3)) {
                    list.remove(t);
                }
            }
            log.info("delete3 方法执行成功");
        }
    
    

    我们来看一下控制台输出的结果:

    21:03:01.697 [main] INFO com.kuake.concurrent.DemoTest - delete1 方法执行成功
    21:03:01.701 [main] INFO com.kuake.concurrent.DemoTest - delete2 方法执行成功
    21:03:01.701 [main] INFO com.kuake.concurrent.DemoTest - delete3 方法遍历删除出现异常,异常类型是ConcurrentModificationException
    

    三、测试结果

    >普通for删除: 删除正常
    >增强for删除: 删除时抛出异常ConcurrentModificationException
    >迭代器删除: 删除正常

    四、异常探究

    为什么使用增强for循环会抛出这个异常呢。首先我来看看增强for遍历编译之后的代码是怎么样。通过idea找到对应的class文件。

     public void delete3() {
            List<Integer> list = this.init();
            Iterator var2 = list.iterator();
    
            while(var2.hasNext()) {
                Integer t = (Integer)var2.next();
                if (t.equals(3)) {
                    list.remove(t);
                }
            }
    
            log.info("delete3 方法执行成功");
        }
    
    

    原来我们的迭代器,在编译之后,jvm也是把它翻译成了使用迭代器进行遍历。那么我们就可以怀疑是不是迭代器遍历的时候有什么要求呢?当翻阅ArrayList的迭代器源码时,看到了如下代码。代码片段如下:这是他的next()方法,

         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];
            }
    

    上述方法中一个checkForComodification() 代码如下:

      final void checkForComodification() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }
    

    modCount 是表示list集合的修改次数,expectedModCount是合理操作时的逾期修改次数;正常操作时modCount==expectedModCount

    **原因:**是因为list.remove()方法会使得modCount++操作;而expectedModCount保存的还是原始值。然后当执行迭代器的 next()操作时就会抛出上述异常。

    五、迭代器的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();
                }
    

    迭代器的remove方法 会将执行expectedModCount = modCount操作。所以在下一次执行next()方法就不会抛出异常。

    六、小结

    推荐使用 迭代器的remove()方法进行集合元素删除操作。

    展开全文
  • 主要介绍了解决JAVA遍历List集合时,删除数据出现的问题,文中讲解非常细致,帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • Java之list集合删除元素1

    千次阅读 2019-09-07 19:13:38
    (1)定义List集合,存入多个字符串,其中包含三个连续的"def" (2)删除集合中字符串"def" (3)然后利用迭代器遍历集合元素并输出 两种方式实现: 代码: import java.util.ArrayList; import java.util.Iterator; ...
  • list集合删除最后一个元素

    千次阅读 2022-05-25 13:19:31
    list.remove(list.size() - 1)
  • 关于List集合删除指定元素相关问题

    千次阅读 2019-05-28 17:48:49
    JAVA中循环遍历list有三种方式for循环、增强for循环(也...1.for循环删除元素 List<String> list = new ArrayList<String>(); list.add("1"); list.add("2"); list.add("3"); list.add("4");...
  • 本文实例分析了C#遍历List删除某个元素的方法。分享给大家供大家参考。具体如下: 1、我们选择用for循环: for(int i=0;i<list u5047设当前遍历到D(i=3),移除,接着遍历i u6b64时跳过了E(i=3) 2、我们使用...
  • List集合的数据的删除操作

    千次阅读 2019-04-24 20:30:39
    在进行List集合删除操作时,新手入手时绝大多数肯定会是for循环遍历List集合。【其中id是一个参数,al是一个List集合的名字】 for(int i=0;i<al.size();i++) { Map<String, Object> map = al.get...
  • List集合删除指定元素

    千次阅读 2021-08-24 15:55:14
    List集合删除指定元素的几种方式 最近在使用这个操作的时候搜索了一下网上的文章,发现有些能用有些不能用,由于使用之前没有做详细的测试,导致程序bug,今天抽空做了一下总结和测试。 package ...
  • List集合for循环删除元素(Java)

    千次阅读 2022-04-21 14:46:14
    List集合不要使用for循环删除元素。
  • List集合删除元素,该怎么删除?

    千次阅读 2016-07-04 22:29:37
    package com.zz.web.controller;import java.util.ArrayList; import java.util.Iterator;public class TestDelList { public static void main(String[] args) { ArrayList<String> list = new ArrayLis
  • 删除list集合中特定元素的正确姿势

    千次阅读 热门讨论 2021-01-18 14:16:03
    如何删除一个集合对象中的特定元素?小问题,但并不简单。 常见异常: ConcurrentModificationException java.util.ConcurrentModificationException at java.util.ArrayList$Itr.checkForComodification(ArrayList...
  • Java删除List集合中元素的方法

    千次阅读 2021-11-12 16:05:11
    先初始化一个List集合 List list = new ArrayList(){ {add(1); add(2); add(3); }}; 1、增强for循环 错误示范 for (Integer i : list) { list.remove(i); } 这样做会抛出异常,因为不允许在元素被使用的时候同时被...
  • 下面小编就为大家带来一篇java中循环遍历删除List和Set集合中元素的方法(推荐)。小编觉得挺不错的,在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 我相信很多同学都写过这样的代码来删除 List 集合内的元素: for (int i = 0; i < list.size(); i++) { if (list.get(i).equals("del")) { list.remove(i); } } 这样的代码有一个弊端,在遍历元素的时候部分...
  • list集合删除重复元素的5种算法

    千次阅读 2020-10-16 16:10:11
    由于list不能在遍历的时候进行删除,因为迭代器内部会维护一些索引位置相关的数据,要求在迭代过程中,容器不能发生结构性变化,否则这些索引位置就失效了。... * 利用set集合的元素不可重复性,删除
  • List集合删除指定的元素

    千次阅读 2021-06-06 13:20:14
    这个问题的坑点在于循环删除掉元素时,后面所有元素的索引都会递减改变,比如...1、使用Iterator迭代器进行操作,迭代器内部会检测list集合的修改次数,并对索引进行校准。 public static void main(String args[]){
  • List集合详细讲解

    千次阅读 2022-06-27 14:39:05
    集合之间的关系 二.List集合三.ArrayList集合 for循环删除方法01 for循环删除方法02for循环删除方法03foreach删除方法迭代器删除01迭代器删除元素02list集合删除方法 四.LinkedList集合五.Vector集合 六....
  • list集合使用迭代器删除元素

    千次阅读 2022-02-24 16:22:19
    集合使用迭代器删除元素
  • java中list集合删除其中的某一个元素

    万次阅读 2019-12-13 09:32:24
    //定义list List<User> list = new ArrayList<>(); User user1 = new User(); User user2 = new User(); user1.serName("111"); user2.serName("222"); list.add(user1); list.ad...
  • 例如:需求:删除list集合中的元素为a List<String> list=new ArrayList<>(); list.add("a"); list.add("b"); list.add("c"); list.add("d"); for(int i=0;i<list.size;i++){ if(list.get(i).equals...
  • 如何从List集合删除对象

    千次阅读 2020-03-11 13:43:00
    void remove(List<Entity> list) { int num = list.size() - 5; for (int i = 0; i < num; i++) { list.remove(i); i--; num--; } }
  • List集合根据条件删除数据

    千次阅读 2018-09-14 11:05:56
    Java三种遍历如何进行list的便利删除: 1、for循环: 常见初五写法:(由于下标问题达不到想要效果)   for(int i=0;i&lt;list.size();i++){ if(list.get(i).equals("del")) list.remove(i); ...
  • List集合删除元素的时候删除不掉

    千次阅读 2016-03-25 22:57:47
    今天博主遇到了List集合删除元素失败的问题,由于自以为对集合比较了解,所以首先排除集合删除的语句的错误 Integer index = 1; list.remove(index); 但是错误就是出现在集合中,我的本意是集合删除下标为制定数据的...
  • Java List集合的应用.rar

    2020-06-24 16:38:03
    Java List集合的简单应用,其中涉及到对集合的添加,删除,应用的功能如下,学生的注册,登录,退出登录,日志的添加,删除,修改逻辑实现,适合新手进行查阅
  • 循环list中的所有元素然后删除重复 public static List removeDuplicate(List list) { for ( int i = 0 ; i < list.size() - 1 ; i ++ ) { for ( int j = list.size() - 1 ; j > i; j -- ) { if (list....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 481,393
精华内容 192,557
关键字:

list集合删除