for循环中删除集合元素隐藏的陷阱

最新推荐文章于 2024-05-01 12:31:54 发布
最新推荐文章于 2024-05-01 12:31:54 发布
阅读量874 收藏 4
点赞数 2
分类专栏： BUG万象集 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Charles_7c/article/details/125660022
版权

前言

C： 今天在审查代码时，发现某位同事提交的代码中有一个比较基础性的错误。

这部分需求的主要目的是将集合中指定的元素删除掉，而这位同事采用的方法是用 for 循环来循环集合索引，然后通过索引从集合中取出每一个元素，判断是否是要删除的元素，如果是就直接删除掉。

大概意思的代码，如下：

// 创建集合，并初始化数据
List<Integer> list = new ArrayList<>(4);
list.add(1);
list.add(2);
list.add(3);
list.add(4);

// 删除元素值为 2 的元素
for (int i = 0; i < list.size(); i++) {
    if (Objects.equals(list.get(i), 2)) {
        list.remove(i);
    }
}

System.out.println(list); // [1, 3, 4]

笔者知道，肯定有同学会好奇，这结果是正确的啊，哪里有什么问题？的确，这个思路没问题，问题的关键是这位同事采用的循环方式存在问题。

别着急，接下来，笔者就带各位同学好好测试一下。

测试代码

基础for循环中删除

直接放代码吧，下方是使用基础的 for 循环（循环索引）来实现的集合元素删除，比之 前言 中的代码，无非是要删除的元素 2 有重复，变成了两个。

/**
 * List集合-循环中删除元素-测试
 *
 * @author Charles7c
 * @date 2021/12/8 20:59
 */
@DisplayName("List集合-循环中删除元素-测试")
public class ListRemoveEleInForLoopTest {

    private List<Integer> list;

    /** 初始化数据 */
    @BeforeEach
    public void init() {
        list = new ArrayList<>(5);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(2);
    }

    /** 运行无异常，测试符合预期 */
    @Test
    @DisplayName("基础for循环中删除元素测试")
    void testBasicForLoop() {
        for (int i = 0; i < list.size(); i++) {
            if (Objects.equals(list.get(i), 2)) {
                // IDEA警告：Suspicious 'List.remove()' in the loop
                list.remove(i);
            }
        }
        System.out.println(list); // [1, 3, 4]
        Assertions.assertEquals(list.size(), 3);
    }

}

测试结果也是正常的啊，莫非笔者失手了？别着急 …

我们再来测试一下，这回我们稍微调整下重复元素的位置，将重复的元素移动到相邻位置。

/**
 * List集合-循环中删除元素-测试
 *
 * @author Charles7c
 * @date 2021/12/8 20:59
 */
@DisplayName("List集合-循环中删除元素-测试")
public class ListRemoveEleInForLoopTest {

    private List<Integer> list;

    /** 初始化数据 */
    @BeforeEach
    public void init() {
        list = new ArrayList<>(5);
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(3);
        list.add(4);
    }

    /** 运行无异常，测试不通过 */
    @Test
    @DisplayName("基础for循环中删除元素测试")
    void testBasicForLoop() {
        for (int i = 0; i < list.size(); i++) {
            if (Objects.equals(list.get(i), 2)) {
                // IDEA警告：Suspicious 'List.remove()' in the loop
                list.remove(i);
            }
        }
        System.out.println(list); // [1, 2, 3, 4]
        Assertions.assertEquals(list.size(), 3);
    }

}

测试不通过，why？

原因很简单： ArrayList 是基于数组结构而来的，在实现 E remove(int index) 方法时，也是在操作数组而已。

E remove(int index) 方法的源代码，如下：

/**
 * Removes the element at the specified position in this list.
 * Shifts any subsequent elements to the left (subtracts one from their
 * indices).
 *
 * @param index the index of the element to be removed
 * @return the element that was removed from the list
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    if (numMoved > 0)
        // 表面看是在拷贝数组，但是源数组和目标数组都是同一个，所以是移动数组元素而已
        // 例如：[1, 2, 3, 4] -> [1, 3, 4, 4]
        System.arraycopy(elementData, index+1, elementData, index,
                numMoved);
    // 元素数量-1，并清除多余元素
    // 例如：[1, 2, 3, 4] -> [1, 3, 4, 4]
    // 最后一个4就是多余的，置为默认值 null
    elementData[--size] = null; // clear to let GC do its work
	
    return oldValue;
}

这样的话就会导致，在循环索引中删除完某个元素，其后面的元素移动到这个元素的位置，但是循环的索引可没回退，这样在取值时就会 跳过下一个元素 。（看不懂的话，可以debug一下，很清晰的）

如果被删除元素的下一个元素不是匹配条件的，那还问题不显，但是如果被删除元素的下一个元素也是匹配条件的，也就会出现刚才测试的结果了。

知道了问题的根源，要是还想要用这种循环，加一行代码就可以了。

/**
 * List集合-循环中删除元素-测试
 *
 * @author Charles7c
 * @date 2021/12/8 20:59
 */
@DisplayName("List集合-循环中删除元素-测试")
public class ListRemoveEleInForLoopTest {

    private List<Integer> list;

    /** 初始化数据 */
    @BeforeEach
    public void init() {
        list = new ArrayList<>(5);
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(3);
        list.add(4);
    }

    /** 运行无异常，测试不通过 */
    @Test
    @DisplayName("基础for循环中删除元素测试")
    void testBasicForLoop() {
        for (int i = 0; i < list.size(); i++) {
            if (Objects.equals(list.get(i), 2)) {
                // IDEA警告：Suspicious 'List.remove()' in the loop
                list.remove(i);
                // !!!回退索引!!!
                i--;
            }
        }
        System.out.println(list); // [1, 3, 4]
        Assertions.assertEquals(list.size(), 3);
    }

}

增强for循环中删除

显然，在基础 for 循环中删除元素，这种方法并不是最好的，那我们就再来看看其他的循环方式吧。

简单改动下代码，看看平时出场频率也很高的增强 for 循环会如何？

/**
 * List集合-循环中删除元素-测试
 *
 * @author Charles7c
 * @date 2021/12/8 20:59
 */
@DisplayName("List集合-循环中删除元素-测试")
public class ListRemoveEleInForLoopTest {

    private List<Integer> list;

    /** 初始化数据 */
    @BeforeEach
    public void init() {
        list = new ArrayList<>(5);
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(3);
        list.add(4);
    }

    /** 运行时异常：java.util.ConcurrentModificationException */
    @Test
    @DisplayName("增强for循环中删除元素测试")
    void testForEachLoop() {
        for (Integer num : list) {
            if (Objects.equals(num, 2)) {
                list.remove(num);
            }
        }
        System.out.println(list);
        Assertions.assertSame(list.size(), 3);
    }

}

测试中断，删除一个元素后继续循环会抛出运行时异常：java.util.ConcurrentModificationException。 Pass …

迭代器中删除

最后，我们再尝试一种循环：迭代器，可能对于部分同学来说，平时使用相对要少一些。

/**
 * List集合-循环中删除元素-测试
 *
 * @author Charles7c
 * @date 2021/12/8 20:59
 */
@DisplayName("List集合-循环中删除元素-测试")
public class ListRemoveEleInForLoopTest {

    private List<Integer> list;

    /** 初始化数据 */
    @BeforeEach
    public void init() {
        list = new ArrayList<>(5);
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(3);
        list.add(4);
    }

    /** 运行无异常，测试符合预期 */
    @Test
    @DisplayName("迭代器中删除元素测试")
    void testIterator() {
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer num = iterator.next();
            if (Objects.equals(num, 2)) {
                iterator.remove();
            }
        }
        System.out.println(list); // [1, 3, 4]
        Assertions.assertSame(list.size(), 3);
    }

}

测试通过，这种方式也是平时 推荐大家采用 的，而且在 Java 8 中，官方还为我们在 Collection 接口中提供了一个 default 方法来简化集合删除元素。

/**
 * List集合-循环中删除元素-测试
 *
 * @author Charles7c
 * @date 2021/12/8 20:59
 */
@DisplayName("List集合-循环中删除元素-测试")
public class ListRemoveEleInForLoopTest {

    private List<Integer> list;

    /** 初始化数据 */
    @BeforeEach
    public void init() {
        list = new ArrayList<>(5);
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(3);
        list.add(4);
    }

    /** 运行无异常，测试符合预期 */
    @Test
    @DisplayName("迭代器中删除元素测试")
    void testIterator() {
        // Java 8 在 Collection 接口中提供的 default 方法
        list.removeIf(num -> Objects.equals(num, 2));
        System.out.println(list); // [1, 3, 4]
        Assertions.assertSame(list.size(), 3);
    }

}

Collection 接口的 removeIf() 方法的源代码，如下：

public interface Collection<E> extends Iterable<E> {
    /**
     * Removes all of the elements of this collection that satisfy the given
     * predicate.  Errors or runtime exceptions thrown during iteration or by
     * the predicate are relayed to the caller.
     *
     * @implSpec
     * The default implementation traverses all elements of the collection using
     * its {@link #iterator}.  Each matching element is removed using
     * {@link Iterator#remove()}.  If the collection's iterator does not
     * support removal then an {@code UnsupportedOperationException} will be
     * thrown on the first matching element.
     *
     * @param filter a predicate which returns {@code true} for elements to be
     *        removed
     * @return {@code true} if any elements were removed
     * @throws NullPointerException if the specified filter is null
     * @throws UnsupportedOperationException if elements cannot be removed
     *         from this collection.  Implementations may throw this exception if a
     *         matching element cannot be removed or if, in general, removal is not
     *         supported.
     * @since 1.8
     */
    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }
    
    // 省略其他代码...
}

很显然，官方也是用的迭代器来实现的。

后记

C： 虽然是一个小问题，但是见到的犯错者无数，以前并未当回事，这次遇到正好记录一下，给各位同学一个提醒。

查尔斯-BUG万象集
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java for循环删除元素_JAVA中循环删除list中元素的方法总结
weixin_36179777的博客
02-12 3337
JAVA中循环遍历list有三种方式for循环、增强for循环(也就是常说的foreach循环)、iterator遍历。1、for循环遍历listfor(int i=0;iif(list.get(i).equals("del"))list.remove(i);}这种方式的问题在于，删除某个元素后，list的大小发生了变化，而你的索引也在变化，所以会导致你在遍历的时候漏掉某些元素。比如当你删除第1个...
list.remove(index)
嗯...
04-14 1962
for (int i = 0; i < selectedList.size(); i++) { if (!buildFunctionList.contains(selectedList.get(i).getType())) { selectedList.remove(i); } } selectedList.remove(i);显示有异常信息： Reports when list.remo...
List集合之remove操作陷阱详解
最新发布
卓越之识论道，平常之识论事，狭隘之识论人
05-01 991
list集合之remove操作陷阱详解
java:for循环删除集合元素的陷阱|浮点数相减少引起的误差|误用八进制|死循环|初始化静态成员变量的陷阱
江说江湖专栏：欠世界一个伟大的产品！
12-05 817
java:for循环删除集合元素的陷阱|浮点数相减少引起的误差|误用八进制|死循环|初始化静态成员变量的陷阱
循环删除 List 中的元素
看一点点书，懂一点点道理，过好这一生
03-02 2079
循环删除 List 中的元素
foreach 循环中删除remove元素
Gzzz的博客
09-13 1448
​1.forEach循环 foreach 语句为数组或对象集合中的每个元素重复一个嵌入语句组。foreach 语句用于循环访问集合以获取所需信息，但不应用于更改集合内容以避免产生不可预知的副作用。 能够应用的编程语言类别：Java、C#、PHP、D语言(Phobos库)。 foreach语句是c#中新增的循环语句，他对于处理数组及集合等数据类型特别方便。 foreach语句的一般语法格式如下： foreach（数据类型 标识符 in 表达式） { 循环体2 }。 Java语言从JDK 1.
java中for循环删除集合陷阱
09-03
总结起来，Java中使用for循环删除集合元素时需谨慎，避免在循环内部直接修改集合。如果必须在循环中进行增删改操作，可以考虑使用迭代器或者`Iterator.remove()`方法，这能更安全地处理集合的动态变化。同时，理解...
详谈python3中用for循环删除列表中元素的坑
09-20
在Python编程语言中，使用`for`循环遍历并删除列表元素时，需要注意一些潜在的问题。本文将深入探讨这些陷阱，以及如何正确地处理类似情况。 首先，`for`循环在Python中是基于迭代器工作的。一个可迭代对象，如列表...
Python for循环中的陷阱详解
09-20
主要给大家介绍了关于Python for循环中陷阱的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
使用Vue中 v-for循环列表控制按钮隐藏显示功能
10-17
本篇文章将详细讲解如何利用`v-for`循环列表来控制按钮的隐藏与显示，以及如何处理列表内的事件绑定，确保事件只对当前列表元素生效。 首先，`v-for`的语法通常是`v-for="item in items"`，其中`items`是源数据数组...
Java for循环Map集合优化实现解析
08-25
例如，在嵌套for循环中，小循环和大循环的集合元素数量分别为M和N，则双层For循环的循环次数是M*N，使用Map集合优化技术可以将循环次数减少到M+N，减少了大量的循环次数。 Java for循环Map集合优化实现解析是一种...
Java并发修改异常ConcurrentModificationException
Small_Lee的博客
05-26 810
我们先看下面的代码public class Demo { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); list.add("A"); list.add("B"); list.add("C");
切记，任何时候都不要在 for 循环中删除 List 集合元素
z1ztai的博客
03-09 125
首先说结论：无论什么场景，都不要对List使用for循环的同时，删除List集合元素，因为这么做就是不对的。阿里开发手册也明确说明禁止使用foreach删除、增加List元素。// 删除元素 iterator . remove();JDK8后lambda写法：list.removeIf(s -> s.contains(“a”));不想知道为什么不能使用for循环删除List集合元素的，看完前言就可以关闭本页面了，想知道原因的继续往下看实例下面举个实例场景，看一下为什么不能使用for循环。
Foreach循环——在循环中删除集合元素
qq_38993995的博客
03-23 3848
Foreach循环——在循环中删除集合元素 在foreach中删除集合元素，代码如下： List<Integer> list = new ArrayList<Integer>(); list.add(1); Iterator<Integer> iterator = list.iterator(); for (Integer i : list ){ //方式一 li
java中for循环删除元素的问题
answers1993ai的专栏
11-03 7533
原来一直没仔细想过java中for循环的删除问题，昨天写一道题时候发现输出结果跟想象不一样，debug时候发现了这个问题，写出来分享一下。
java for循环删除元素_java中使用for循环删除集合中元素的注意点
weixin_39886238的博客
02-12 179
场景：使用for循环删除集合中的指定元素定义一个list集合，并添加数据：List list=new ArrayList<>();list.add("b");list.add("e")list.add("b");list.add("c");需求：删除该集合中所有字符串为b的数据，代码如下:for (int i = 0; i < list.size(); i++) {if("b"....
ArrayList Iterator remove java.lang.UnsupportedOperationException
liuzhigang1237的专栏
01-12 5970
在使用Arrays.asList()后调用add，remove这些method时出现java.lang.UnsupportedOperationException异常。这是由于Arrays.asList() 返回java.util.Arrays$ArrayList， 而不是ArrayList。Arrays$ArrayList和ArrayList都是继承AbstractList，remove，add
List循环使用remove()方法
Java兔的博客
11-16 2400
小记有时候敲代码会遇到这种情况，循环一个list，执行完一个后就要移除它，然后继续循环，如果不注意写很容易运行报错：java.util.ConcurrentModificationException。在阅读《Java编程思想》时，看到一种很好的写法，不由地想记录下来，在这里简称为方法一，另外还有一种常用的方法，简称为方法二，下面是两个方法的代码：方法一List<String> list = new
如何在for循环中或许集合元素的长度
05-25
你可以使用len()函数来获取集合元素的长度，例如： ...在上述代码中，我们使用了len()函数来获取my_list中每个元素的长度，并在for循环中打印出来。你可以根据需要将代码调整为适合不同类型的集合。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

查尔斯-BUG万象集

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

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

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

打赏作者

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

抵扣说明：

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

余额充值