What basic operations on a Map are permitted while iterating over it?

Question

Say I am iterating over a Map in Java... I am unclear about what I can to that Map while in the process of iterating over it. I guess I am mostly confused by this warning in the Javadoc for the Iterator interface remove method:

[...] The behavior of an iterator is unspecified if the underlying collection is modified while the iteration is in progress in any way other than by calling this method.

I know for sure that I can invoke the remove method without any issues. But while iterating over the Map collection, can I:

1. Change the value associated with a key with the Map class put method (put with an existing key)?

2. Add a new entry with the Map class put method (put with a new key)?

3. Remove an entry with the Map class remove method?

My guess is that I can probably safely do #1 (put to an existing key) but not safely do #2 or #3.

Thanks in advance for any clarification on this.

Answer 1

In general, if you want to change the Map while iterating over it, you should use one of the iterator's methods. I have not actually tested to see if #1 will will work, but the others definitely will not.

Answer 2

If you take a look at the HashMap class, you'll see a field called 'modCount'. This is how the map knows when it's been modified during iteration. Any method that increments modCount when you're iterating will cause it to throw a ConcurrentModificationException.

That said, you CAN put a value into a map if the key already exists, effectively updating the entry with the new value:

 Map<String, Object> test = new HashMap<String, Object>();
 test.put("test", 1);

 for(String key : test.keySet())
 {
     test.put(key, 2); // this works!
 }

 System.out.println(test); // will print "test->2"

When you ask if you can perform these operations 'safely,' you don't have to worry too much because HashMap is designed to throw that ConcurrentModificationException as soon as it runs into a problem like this. These operations will fail fast; they won't leave the map in a bad state.

Answer 3

You can use Iterator.remove, and if using an entrySet iterator (of Map.Entry's) you can use Map.Entry.setValue(). Anything else and all bets are off - you should not change the map directly, and some maps will not permit either or both of the aforementioned methods.

Specifically, your (1) is risky, and (2) and (3) are NOT permitted.

Answer 4

Are you using multi threading?

Iterating over a map and chaning the map at the same time should be done very careful. Use a synchronized Map to get sure that nothing breaks at runtime.

When you want to show a Map in one thread and want to give the user to change the Map at the same time, copy the Map before you are starting to iterate. The copied Map you can display and every time the display is updated, the current Map is used.

When you are using one thread you can get the Map keys and iterate over this keys. Then you can change the map easily, because the Key Set will destine the number of iteration steps.

Answer 5

There is no global answer. The map interface let the choice to the users. Unfortunately, I think that all the implementations in the jdk use the fail-fast implementation (here is the definition of fail-fast, as it stated in the HashMap Javadoc):

The iterators returned by all of this class's "collection view methods" are fail-fast: if the map is structurally modified at any time after the iterator is created, in any way except through the iterator's own remove method, the iterator will throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.