记一次使用list删除元素

最新推荐文章于 2023-04-17 11:20:35 发布
最新推荐文章于 2023-04-17 11:20:35 发布
阅读量172 收藏 1
点赞数 1
分类专栏： 基础 文章标签： java arraylist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43887814/article/details/106924650
版权

常见list遍历方法

  • 普通for循环遍历
  • 增强for循环遍历
  • 迭代器遍历
普通for循环
List<String> list = new ArrayList<>();
list.add("1");
list.add("1");
list.add("1");
list.add("2");
list.add("3");
for (int i = 0; i < list.size(); i++) {
	if ("1".equals(list.get(i))) {
		list.remove(list.get(i));
	}
}

看似条件相等，进行删除，没有问题，实则失败…

原因：
ArrayList底层是数组结构，所以每一个元素下面会有对应下标，从上面list举例，下标为 0-4；当第一个元素进入if判断，返回true，进入if，删除，此时下标重新排列，原本下标为“1”的元素此时下标为“0”，此时，由于刚才循环结束，i++，i等于1；所以再次进入循环，进行判断，list.get(1)，得到了list中第二个元素，所以跳过了原本的第二个元素；得出结论，当list去重时，使用普通for循环会漏掉两个相邻且相同的第二位满足条件的元素。
解决办法：
这个想要解决也是很简单的，代码如下：

if ("1".equals(list.get(i))) {
	list.remove(list.get(i));
	i--;
}

当list移除满足条件之后，将循环次数i进行减一操作。

增强for循环
for (String str: list) {
	if("1".equals(str)) {
		list.remove(str);
	}	
}

同样看似没有问题，实则抛出java.util.ConcurrentModificationException。

原因：

先看ArralList源码

package com.workit.demo.array;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Predicate;

/**
 * @author:
 * @Date: 2020/6/9
 * @Description:
 */
public class ArrayListDelete {

    public static void main(String[] args) {

        Predicate<String> predicate = p -> p.equals("a") || p.equals("b");

        // 可以正常删除结果正确
        deleteByIterator(getList(), predicate);

        // 可以正常删除结果正确
        deleteByReverseOrder(getList(), predicate);

        // 可以删除 结果不正确
        deleteByOrder(getList(), predicate);

        // 不能删除 报错java.util.ConcurrentModificationException
        deleteByArrayList(getList(), predicate);

        // 不能删除 报错java.util.ConcurrentModificationException
        deleteByForeach(getList(), predicate);

        //不能删除 报错 java.util.ConcurrentModificationException
        deleteByEnhancedForLoop(getList(), predicate);
  // 正常删除数据  
  deleteAll(getList(), predicate);

    }

    public static  List<String> getList() {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        return list;
    }



    /**
     * 普通for循环倒序删除
     * 可以正常删除  结果正确
     * @param list
     * @param predicate
     */
    public static void deleteByReverseOrder(List<String> list, Predicate<String> predicate) {
        for (int i = list.size() - 1; i >= 0; i--) {
            if (predicate.test(list.get(i))) {
                list.remove(list.get(i));
            }
        }
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()+":"+list.toString());
    }

    /**
     * 普通for循环正序删除
     *可以删除  结果不正确
     * @param list
     * @param predicate
     */

    public static void deleteByOrder(List<String> list, Predicate<String> predicate) {
        for (int i = 0; i < list.size(); i++) {
            if (predicate.test(list.get(i))) {
                list.remove(list.get(i));
            }
        }
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()+":"+list.toString());
    }


    /**
     * 迭代器循环，使用ArrayList的remove()方法删除
     * 可以删除  结果不正确
     * @param list
     * @param predicate
     */
    public static void deleteByArrayList(List<String> list, Predicate<String> predicate) {
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            if (predicate.test(iterator.next())) {
                list.remove(iterator.next());
            }
        }
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()+":"+list.toString());

    }

    /**
     * 迭代器循环，使用迭代器的remove()方法删除
     * 可以正常删除结果正确
     * @param list
     * @param predicate
     */
    public static void deleteByIterator(List<String> list, Predicate<String> predicate) {
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            if (predicate.test(iterator.next())) {
                iterator.remove();
            }
        }
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()+":"+list.toString());

    }

    /**
     * java8 forEach方法删除
     *不能删除 报错 java.util.ConcurrentModificationException
     * @param list
     * @param predicate
     */
    public static void deleteByForeach(List<String> list, Predicate<String> predicate) {
        list.forEach(p -> {
            if (predicate.test(p)) {
                list.remove(p);
            }
        });
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()+":"+list.toString());

    }
    /**
     * 增强版for循环删除
     *不能删除 报错 java.util.ConcurrentModificationException
     * @param list
     * @param predicate
     */
    public static void deleteByEnhancedForLoop(List<String> list, Predicate<String> predicate) {
        for (String string : list) {
            if (predicate.test(string)) {
                list.remove(string);
            }
        }
    }

}
 /**
     * 调用批量删除方法
     * @param list
     * @param predicate
     */
    public static void deleteAll(List<String> list, Predicate<String> predicate) {
        List<String> removeList = new ArrayList<>();
        for (String string : list) {
            if (predicate.test(string)) {
                removeList.add(string);
            }
        }
        list.removeAll(removeList);
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName()+":"+list.toString());

    }

增强版for循环删除 && 迭代器循环使用ArrayList.remove()方法删除

增强版for循环删除（deleteByEnhancedForLoop）、迭代器循环，使用ArrayList的remove()方法删除（deleteByArrayList）这两种姿势都会抛出java.util.ConcurrentModificationException，他们本质都是迭代器循环，每次循环都会checkForComodification这个方法检查modCount 和expectedModCount的值。

@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];
        }
         final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

而List的删除方法每次删除之后modCount都会进行加1操作，expectedModCount值不变还是原来的。

private void fastRemove(int index) {
        modCount++; //modCount`都会进行加1操作
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
}

所以都会抛出ConcurrentModificationException异常。

推荐做法：迭代器循环

迭代器循环，使用迭代器的remove()方法删除（deleteByIterator）这个比较简单我们直接看迭代器的删除 关键代码就一行 expectedModCount = modCount。

public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount; //调用ArrayList的删除方法后多了这么一句话。
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

当然，这种方式也是《阿里开发手册》当中所推荐的写法。

在这里插入图片描述

附 阿里开发手册 泰山版

网址：https://pan.baidu.com/s/13GVC43hsGISvuJhXFkDIjg
提取码：j863

刘水水
关注
专栏目录
问题总结：一个 list 使用 for 遍历，边循环边删除的问题
采菊东篱下，Python满乾坤！
08-19 906
对一个 list 数据类型写一个循环删除的程序。
python删除list元素小结
IceelfLuo的博客
08-18 1396
昨天在工作中遇到在list里删除元素的小bug，后来发现网上已经有不少人总结提炼了一下bug的发生原因和处理方法，我自己也记录一下。 问题 # Delete elements from a list def remove_list(li,drop_list): for i in li: inx = li.index(i) if i in drop_list: del li[inx] print(li) li1 = [1, 2, 2,
关于List删除元素问题
进三步的博客
07-15 305
public class ListTes { /** * @param args */ public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("a"); list.add("b"); list.add("c"); list.add("d"); list.add("e"); List<String.
删除List中元素的正确姿势
linlinxie的博客
10-29 1465
通常需要把List中的某些元素进行删除，容易犯的错误就是直接做循环，然后if判断进行删除，这种往往会报错，因为列表大小以及指针同时改变了，之所以说往往，是因为删除某些元素时并不会报错。如下所示：//main函数 public static void main(String[] args) { List<String> originList = new ArrayList<String
@Delete通过批量删除的方法
最新发布
qq_19891197的博客
04-17 2019
@Delete通过批量删除的方法
mybatis框架——实战练习——第一个spring boot + mybatis项目——在第一个项目的基础上删除一条记录...
小白龙白龙马的博客
05-22 168
POJO类不变 mybatis映射文件： <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> &...
mybatis注解开发 @Delete 批量删除
qq_40308101的博客
06-28 3563
@Delete(" DELETE FROM webapp.error_alarm WHERE id in #{id} ") int deleteByIdBatch(List ids);
python list删除元素时要注意的坑点分享
09-20
在Python编程中，列表(list)是常用的数据结构之一，它允许动态添加、修改和删除元素。然而，在处理列表时，特别是在删除元素时，如果不注意一些细节，可能会遇到意想不到的问题。本文将深入探讨Python列表删除元素时...
Python 查找list中的某个元素的所有的下标方法
09-20
5. 将`first_pos`更新为`next_pos`，即当前找到的元素位置的下一个位置，这样在下一次循环中可以跳过已经查找过的位置。 不过，这种方法实际上存在一些问题。例如，如果列表中的元素较多，每次循环都截取一个新列表...
List中元素查找，元素删除，元素排序
weixin_40883446的博客
06-26 1万+
list一个简单介绍：    List是一个接口，主要实现类有两个LinkedList，ArrayList，两者在底层实现上有差异，LinkedList底层采用的是链表存储，ArrayList底层采用的是顺序存储。    List的特征：存放元素有序，且可重复查找：    根据list下标查找元素： list.get(index)    根据元素查找第一次出现的位置 ：list.indexOf(o...
delete里不能放list集合
码农怀仔
08-07 1645
          getSession().delete(role)               }  )  };}
删除 List 元素的三种正确方法
热门推荐
C30混凝土
12-13 3万+
// 每次都会计算list.size()比较耗费性能 public static void remove1 (List &lt; String &gt; list, String target){ for (int i = list.size() - 1; i &gt;= 0; i--) { String item = lis...
java 集合 delete,随笔：List 集合的删除（JDK1.8）
weixin_32098487的博客
03-12 1132
Forech在遍历List集合的时候是不可以做add/remove操作的。List list = new ArrayList<>();list.add("a");list.add("b");list.add("c");for (String s : list) {list.remove(s);}报错：Exception in thread "main" java.util.Concur...
删除顺序表指定元素
架构师之路，举步维艰。
03-25 1689
干掉线性表指定元素
Java8新增的removeIf(Predicate filter)方法、Predicate的用法
c梦的博客
08-11 8858
Java8新增的removeIf(Predicate filter)方法：该方法将会批量删除符合filter条件的所有元素，该方法需要一个Predicate对象作为参数，Predicate也是函数式接口，因此可以使用Lambda表达式。 例： public class PredicateTest { public static void main(String[] args) { ...
JDBC连接数据库步骤
博客
01-12 1万+
一、导入jar包 二、加载驱动:Class.forName(“驱动的路径”); 三、获取数据库连接对象 Connection con=null; con=DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:orcl", "user", "123"); jdbc:oracle----表示用jdbc连接Oracle数据库;...
ArrayList 与 LinkedList 区别
博客
12-04 395
ArrayList 与 LinkedList 区别 ArrayList ArrayList 有明确下标，所以查询速度较快，但是增删速度较慢，因为增 删 元素会导致其他元素下标移动 LinkedList LinkedList 没有明确下标，所以查询速度较慢，增删速度较快 例如 输出结果为 毫秒差值为16ms 现在来看LinkedList 相同的代码 只把ArrayList换成了...
Nginx和tomcat集群
博客
06-04 236
什么是nginx? 我们可以了解到Nginx是一个http服务器。是一个使用c语言开发的高性能的http服务器及反向代理服务器。Nginx是一款高性能的http 服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器。由俄罗斯的程序设计师Igor Sysoev所开发，官方测试nginx能够支撑10万并发链接，并且cpu、内存等资源消耗却非常低，运行非常稳定。 Nginx能干什么? ...
批量操作SQL语句：删除与更新记录
批量删除文本是IT编程中的一个重要概念，主要涉及到在数据库操作中通过脚本或SQL语句实现对大量数据的一次性处理。在Java编程中，特别是使用MyBatis这样的持久层框架时，我们经常遇到这种情况。以下是一些关键知识点...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

刘水水

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值