java HashMap需要注意的一些地方

来源：互联网发布：祛痘图片淘宝编辑：程序博客网时间：2024/05/16 15:06

在游戏服务器上控制角色的坐标点可以通过Point这个类来实现，地图模块则以HashMap来承载。此问题从简单来说，既HashMap以Point作为Key值时，用户往往会忽略其中一个细节照成后期的非编译Bug。

以下是示例：

HashMap<Point,String> hashMap = new HashMap<Point, String>();
Point A = new Point(2,2);
hashMap.put(A,"A");//将2,2点作为Key值存入HashMap
A.x = 1;//修改A点的x值
A.y = 1;//修改A点的y值
System.out.println(hashMap.get(A));//此时结果为Null 已经找不到了

//我们试着迭代一下
System.out.println(hashMap.size());//此处为1
for(Iterator<String> iterator = hashMap.values().iterator();iterator.hasNext();){
iterator.next();
iterator.remove();
}
System.out.println(hashMap.size());//此处依旧为1 即无法销毁

所以使用Point作为HashMap的Key时大家要注意了这个Point应当是Final态即不可修改的否则将发生在HashMap中无法找到对应Value也无法迭代删除的错误

当然其他以对象作为Key值时也应当注意
原因是hashMap的索引是通过Key的hashcode进行的当用户人为修改对象的内部属性后会造成hashcode的变化从而造成无法取得Value的错误

以上为本人Java游戏服务器开发中一些小小的总结

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

Java遍历HashMap并修改(remove)

2条评论

遍历HashMap的方法有多种，比如通过获取map的keySet, entrySet, iterator之后，都可以实现遍历，然而如果在遍历过程中对map进行读取之外的操作则需要注意使用的遍历方式和操作方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class MapIteratorTest {
 
    private static Map<Integer, String> map = new HashMap<Integer, String>();
 
    public static void main(String[] args) {
        //init
        for(int i = 0; i < 10; i++){
            map.put(i, "value" + i);
        }
 
        for(Map.Entry<Integer, String> entry : map.entrySet()){
             Integer key = entry.getKey();
             if(key % 2 == 0){
                 System.out.println("To delete key " + key);
                 map.remove(key);
                 System.out.println("The key " + + key + " was deleted");
             }
        }
 
        System.out.println("map size = " + map.size());
        for(Map.Entry<Integer, String> entry : map.entrySet()){
            System.out.println( entry.getKey() +" = " + entry.getValue());
        }
    }
}

上面代码的输出结果为

1
2
3
4
5
6
7
Todeletekey0
Thekey0wasdeleted
Exceptioninthread"main"java.util.ConcurrentModificationException
    atjava.util.HashMap$HashIterator.nextEntry(HashMap.java:793)
    atjava.util.HashMap$EntryIterator.next(HashMap.java:834)
    atjava.util.HashMap$EntryIterator.next(HashMap.java:832)
    atcom.gpzuestc.collection.MapIteratorTest.main(MapIteratorTest.java:60)

通过上面的输出可以发现第一个偶数key元素已经被成功remove，异常的抛出位置是在迭代器遍历下一个元素的时候。

如果把上面高亮的遍历代码替换成keySet的方式，通过keySet的remove操作同样会在遍历下个元素时抛出异常，示例如下。

1
2
3
4
5
6
7
8
        Set<Integer> keySet = map.keySet();
        for(Integer key : keySet){
            if(key % 2 == 0){
                System.out.println("To delete key " + key);
                keySet.remove(key);
                System.out.println("The key " + + key + " was deleted");
             }
        }

1
2
3
4
5
6
Todeletekey0
Thekey0wasdeleted
Exceptioninthread"main"java.util.ConcurrentModificationException
    atjava.util.HashMap$HashIterator.nextEntry(HashMap.java:793)
    atjava.util.HashMap$KeyIterator.next(HashMap.java:828)
    atcom.gpzuestc.collection.MapIteratorTest.main(MapIteratorTest.java:49)

如果要实现遍历过程中进行remove操作，上面两种方式都不能使用，而是需要通过显示获取keySet或entrySet的iterator来实现。

1
2
3
4
5
6
7
8
9
10
11
        Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
        while(it.hasNext()){
            Map.Entry<Integer, String> entry = it.next();
            Integer key = entry.getKey();
            if(key % 2 == 0){
                System.out.println("To delete key " + key);
                it.remove();    
                System.out.println("The key " + + key + " was deleted");
 
            }
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Todeletekey0
Thekey0wasdeleted
Todeletekey2
Thekey2wasdeleted
Todeletekey4
Thekey4wasdeleted
Todeletekey6
Thekey6wasdeleted
Todeletekey8
Thekey8wasdeleted
mapsize=5
1=value1
3=value3
5=value5
7=value7
9=value9

分析原因

其实上面的三种遍历方式从根本上讲都是使用的迭代器，之所以出现不同的结果是由于remove操作的实现不同决定的。

首先前两种方法都在调用nextEntry方法的同一个地方抛出了异常

1
2
3
4
5
6
7
    final Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            ...
            ...
     }

这里modCount是表示map中的元素被修改了几次(在移除，新加元素时此值都会自增)，而expectedModCount是表示期望的修改次数，在迭代器构造的时候这两个值是相等，如果在遍历过程中这两个值出现了不同步就会抛出ConcurrentModificationException异常。

1、HashMap的remove方法实现

1
2
3
4
publicVremove(Objectkey){
    Entry<K,V>e=removeEntryForKey(key);
    return(e==null?null:e.value);
}

2、HashMap.KeySet的remove方法实现

1
2
3
public boolean remove(Object o) {
    return HashMap.this.removeEntryForKey(o) != null;
}

3、HashMap.HashIterator的remove方法实现

1
2
3
4
5
6
7
8
9
10
publicvoidremove(){
  if(current==null)
        thrownewIllegalStateException();
  if(modCount!=expectedModCount)
        thrownewConcurrentModificationException();
  Objectk=current.key;
  current=null;
  HashMap.this.removeEntryForKey(k);
  expectedModCount=modCount;
}

以上三种实现方式都通过调用HashMap.removeEntryForKey方法来实现删除key的操作。在removeEntryForKey方法内只要移除了key modCount就会执行一次自增操作，此时modCount就与expectedModCount不一致了，上面三种remove实现中，只有第三种iterator的remove方法在调用完removeEntryForKey方法后同步了expectedModCount值与modCount相同，所以在遍历下个元素调用nextEntry方法时，iterator方式不会抛异常。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
    final Entry<K,V> removeEntryForKey(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;
 
        while (e != null) {
            Entry<K,V> next = e.next;
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;
                size--;
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }
 
        return e;
    }

发散

1、如果是遍历过程中增加或修改数据呢？
增加或修改数据只能通过Map的put方法实现，在遍历过程中修改数据可以，但如果增加新key就会在下次循环时抛异常，因为在添加新key时modCount也会自增。

2、有些集合类也有同样的遍历问题，如ArrayList，通过Iterator方式可正确遍历完成remove操作，直接调用list的remove方法就会抛异常。

1
2
3
4
5
6
7
8
9
10
11
//会抛ConcurrentModificationException异常
for(Stringstr:list){
    list.remove(str);
}
 
//正确遍历移除方式
Iterator<String>it=list.iterator();
while(it.hasNext()){
    it.next();
    it.remove();
}

3、jdk为什么这样设计，只允许通过iterator进行remove操作？

HashMap和keySet的remove方法都可以通过传递key参数删除任意的元素，而iterator只能删除当前元素(current)，一旦删除的元素是iterator对象中next所正在引用的，如果没有通过modCount、 expectedModCount的比较实现快速失败抛出异常，下次循环该元素将成为current指向，此时iterator就遍历了一个已移除的过期数据。

0 0