`
vanceinfo_xuefei
  • 浏览: 9323 次
  • 性别: Icon_minigender_1
  • 来自: 南京
最近访客 更多访客>>
文章分类
社区版块
存档分类
最新评论

java中使用迭代器时的注意点

    博客分类:
  • JAVA
阅读更多
    工作跟生活一样,都是一个困难接着一个困难的阻挡在我们面前,而如果我们需要前进就需要把这些困难一一干掉才可以。
    昨天又碰见一个问题,跟大家分享下...
    Map<String, Integer> catalogIds = new HashMap<String, Integer>();
    catalogIds =
        ShoppingCartDao.getInstance().getcatalogs(userId, productIds);
                if (!catalogIds.isEmpty() && catalogIds.size() > 0)
                {
                    Set<Map.Entry<String, Integer>>set=              catalogIds.entrySet();
                    Iterator<Entry<String, Integer>> it = set.iterator();
                    while (it.hasNext())
                    {
                        String catalogId = it.next().getKey();
                        if (catalogIds.get(catalogId) < 2)
                        {
                            //it.remove();
                            catalogIds.remove(catalogId);
                        }
                    }
                }

如果按照上面这样写
while (it.hasNext())
                    {
                        String catalogId = it.next().getKey();
                        if (catalogIds.get(catalogId) < 2)
                        {
                            //it.remove();
                            catalogIds.remove(catalogId);
                        }
                    }
这段代码会出现java.util.concurrentmodificationexception异常...
经过查阅资料跟分析原因如下:
下面来看一下源码
public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

public interface Collection<E> extends Iterable<E> {
    ...
    Iterator<E> iterator();
    boolean add(E o);
    boolean remove(Object o);
    ...
}
这里有两个remove方法

接下来来看看AbstractList
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> { 
//AbstractCollection和List都继承了Collection
    protected transient int modCount = 0;
    private class Itr implements Iterator<E> {  //内部类Itr
        int cursor = 0;
        int lastRet = -1;
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size();
        }

        public E next() {
            checkForComodification();  //特别注意这个方法
            try {
                E next = get(cursor);
                lastRet = cursor++;
                return next;
            } catch(IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }

        public void remove() {
            if (lastRet == -1)
                throw new IllegalStateException();
            checkForComodification();

            try {
                AbstractList.this.remove(lastRet);  //执行remove对象的操作
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount;  //重新设置了expectedModCount的值,避免了ConcurrentModificationException的产生
            } catch(IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)  //当expectedModCount和modCount不相等时,就抛出ConcurrentModificationException
                throw new ConcurrentModificationException();
        }
    }   
}

remove(Object o)在ArrayList中实现如下:
public boolean remove(Object o) {
    if (o == null) {
            for (int index = 0; index < size; index++)
        if (elementData[index] == null) {
            fastRemove(index);
            return true;
        }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
private void fastRemove(int index) {
    modCount++;  //只增加了modCount
    ....
}

所以,产生ConcurrentModificationException的原因就是:
执行remove(Object o)方法之后,modCount和expectedModCount不相等了。然后当代码执行到next()方法时,判断了checkForComodification(),发现两个数值不等,就抛出了该Exception。
要避免这个Exception,就应该使用remove()方法。
这里我们就不看add(Object o)方法了,也是同样的原因,但没有对应的add()方法。一般嘛,就另建一个List了


下面是网上的其他解释,更能从本质上解释原因:
Iterator 是工作在一个独立的线程中,并且拥有一个 mutex 锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表,当原来的对象数量发生变化时,这个索引表的内容不会同步改变,所以当索引指针往后移动的时候就找不到要迭代的对象,所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。
所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象, Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。
while (it.hasNext())
                    {
                        String catalogId = it.next().getKey();
                        if (catalogIds.get(catalogId) < 2)
                        {
                            it.remove();
                            catalogIds.remove(catalogId);
                        }
                    }

解决方案是将加上it.remove();使迭代器的索引表长度也变化,保持一致...
不知道各位还有没有什么其他的解决方案...

   
分享到:
评论
1 楼 ljc1551008936 2012-03-01  

相关推荐

    java Iterator迭代器的使用

    迭代器的主要方法包括`hasNext()`(检查集合中是否存在下一个元素)、`next()`(返回当前元素并移动到下一个)和`remove()`(删除当前元素)。 2. **获取迭代器** 要使用`Iterator`,首先需要通过调用集合类的`...

    Java学习之Iterator(迭代器)的一般用法

    在深入探讨Java中Iterator(迭代器)的一般用法之前,我们先来理解一下迭代器在编程中的核心价值。迭代器是一种设计模式,其主要作用在于遍历集合中的元素,而无需开发者知晓集合的具体实现细节。这使得代码更加灵活、...

    java基础 集合-22-迭代器设计模式

    在Java编程语言中,集合框架是处理对象数组的核心部分,而迭代器设计模式则是访问集合元素的主要机制。本文将深入探讨Java中的迭代器模式及其在集合框架中的应用。 迭代器模式是一种行为设计模式,它提供了一种方法...

    迭代器的用法

    下面我们将详细探讨Java中迭代器的用法及其相关知识点。 1. **迭代器接口**: Java中的`Iterator`接口位于`java.util`包中,定义了三个主要的方法: - `boolean hasNext()`: 检查迭代器是否还有更多的元素,如果...

    详解Java中Iterator迭代器的用法

    迭代器模式是设计模式中的一种,它允许程序员访问聚合对象的元素,同时不暴露其内部表示。下面我们将深入探讨Java中`Iterator`的使用方法和特点。 ### 1. `Iterator`接口概述 `Iterator`接口位于`java.util`包中,...

    Android设计模式之--迭代器模式

    在Java或Android编程中,我们经常使用ArrayList、LinkedList等集合类,它们都提供了迭代器接口来实现这一模式。 在Android设计模式中,迭代器模式的主要作用是分离了聚合对象(如数组、列表)与遍历它的方法。这样...

    解析Java的迭代器中的fast-fail错误检测机制

    Java的迭代器中的fast-...在Java中,迭代器(Iterator)被设计用来遍历和修改集合,当一个线程正在使用迭代器遍历集合时,如果另一个线程修改了集合的内容(添加、删除或修改元素),就会触发fast-fail机制,从而抛出`...

    迭代器的使用.docx

    迭代器模式在Java编程语言中得到了广泛的应用,特别是在处理集合类,如ArrayList、LinkedList等时。在Java中,迭代器是通过`Iterator`接口实现的,它允许程序员遍历集合中的元素,而不必了解集合的内部结构。 迭代...

    Java集合框架迭代器Iterator实现原理解析

    2、使用迭代器时,需要注意遍历的顺序和性能问题。 迭代器是一个非常重要的接口,用于遍历容器中的元素。通过了解迭代器的实现原理、使用方法和注意事项,可以更好地使用迭代器,提高开发效率和质量。

    【IT十八掌徐培成】Java基础第10天-04.List-迭代器-对象等价性.zip

    当在一个线程中使用迭代器遍历List,而在另一个线程中修改List时,如果不使用迭代器进行操作,可能会导致不预期的行为。 5. **示例代码**: ```java List&lt;String&gt; list = new ArrayList(); list.add("Element1")...

    Java中的迭代器和foreach原理

    Java中的迭代器(Iterator)和foreach循环是两种常用的遍历集合和数组的方式。迭代器模式是一种行为设计模式,它的核心作用在于允许用户遍历任何集合或聚合对象的元素,而无需暴露其底层结构。在Java中,迭代器主要...

    内置迭代器的linked list例题

    而内置迭代器(Iterator)是Java集合框架的重要组成部分,用于遍历集合中的元素,特别是对于LinkedList这种非连续内存存储的数据结构,迭代器提供了一种高效且方便的方式来访问其元素。下面我们将深入探讨LinkedList...

    Java Iterator接口遍历单列集合迭代器原理详解

    代码执行后的结果:在进行集合元素取出时,如果集合中已经没有元素了,还继续使用迭代器的next方法,将会发生java.util.NoSuchElementException没有集合元素的错误。 迭代器的实现原理:当遍历集合时,首先通过调用...

    java-leetcode题解之第173题二叉搜索树迭代器.zip

    在这个Java题解中,作者可能使用了以上的一种或多种方法来实现二叉搜索树迭代器。解题过程中,需要注意以下几点: - 初始化迭代器时,需要记录当前节点和前一个节点,因为我们需要在遍历时保持升序顺序。 - 在 `...

    迭代器的使用 (2).pdf

    以下是关于Java迭代器的一些关键知识点: 1. **获取迭代器**: 要使用迭代器,首先需要通过集合类的`iterator()`方法获取一个迭代器实例。例如: ```java Iterator&lt;Cat&gt; e = cats.iterator(); ``` 2. **遍历元素...

    iterator-demo 迭代器设计模式demo

    在“iterator-demo”项目中,你可能会看到如何创建一个自定义的聚合类和迭代器类,以及如何在客户端代码中使用这些类来遍历元素。这个例子将帮助你理解迭代器模式的工作原理,以及如何在实际项目中实现和使用。通过...

    设计模式_行为型_迭代器模式.md

    在Java中,`java.util.ArrayList`就使用了迭代器模式来遍历列表中的元素。`ArrayList`类内部定义了一个私有静态类`Itr`作为具体的迭代器类,实现了`Iterator`接口。 ### 详细的示例解释 在给出的示例代码中,`...

    2 迭代器模式-MOOC课程内容.pdf

    在实现迭代器模式时,需要特别注意迭代器的状态管理。因为迭代器需要记录当前遍历的位置,所以必须保证这种状态的同步和一致性,以避免潜在的错误和数据不一致的情况。在设计具体迭代器时,开发者还需要考虑如何最...

    怎么将利用DWR调用JAVA类方法所返回的ArrayList数组   赋值给   logiciterate 迭代器

    通过上述步骤,我们可以有效地使用DWR调用Java类中的方法获取数据,并将返回的ArrayList数组赋值给前端的逻辑迭代器。这种方式不仅简化了前后端之间的交互逻辑,还提高了程序的可维护性和扩展性。对于需要频繁进行...

    Java中迭代器Iterator的使用解析

    Java中迭代器Iterator的使用解析 Java中的迭代器Iterator是一种设计模式,用于遍历容器中的元素,提供了公共的操作接口,实现了对容器的遍历操作与其具体的底层实现相隔离,达到解耦的效果。 在Java中,Iterator...

Global site tag (gtag.js) - Google Analytics