设置地图。迭代完成后输入值？

Question

我可以在临时地图中保存地图。输入对象，然后在迭代完成后返回并更改其值吗？

例如，以下以两个步骤实现了一种交易。在步骤1中，递归处理条目的条目和条目地图（因此，一棵树）。条目被处理为新值，这些值将保存到临时地图，并由相应的地图键入。如果无一例外地计算所有条目，则步骤2就是简单地迭代临时地图并分配相应的新值。

void performPerilousProcedure(Object val) throws Exception
{
    if (processing of val fails)
        throw new Exception();
}
void recurivePerilousProcedure(Map someMap, Map tmp) throws Exception
{
    Iterator<Map.Entry<String,Object>> iter1;
    iter1 = someMap.entrySet().iterator();
    while (iter1.hasNext()) {
        Map.Entry<String,Object> entry1 = iter1.next();
        Object val = entry1.getValue();
        if (val instanceof Map) {
            recursivePerilousProcedure((Map)val, tmp);
        } else {
            Object newval = performPerilousProcedure(val);
            // ok to use Map.Entry as key across iter?
            tmp.put(entry1, newval);
        }   
    }   
}
void doit(Map<String,Object> someMap) throws Exception
{
    HashMap<Map.Entry<String,Object>,Object> tmp = new HashMap();
    // Try to process map of entries and maps of entries and ma ... 
    recursivePerilousProcedure(someMap, tmp);
    // All entries success processed, now simply assign new vals
    Iterator<Map.Entry<String,Object>> iter2;
    iter2 = tmp.keySet().iterator();
    while (iter2.hasNext()) {
        Map.Entry<String,Object> entry2 = iter2.next();
        Object newval = tmp.get(entry2);
        entry2.setValue(newval); // commit new value
    }   
}

问题是：

map.entry 用作 tmp 的对象可以在迭代外生存吗？

只要没有并发修改，这是MAP接口的有效使用吗？

Answer 1

map.entry 对此非常清楚：

这些实例保持了与原始背景图的连接。在入门集视图上，在迭代持续时间内，与背映射的此连接仅是有效的 。在入门集视图的迭代期间，如果由备用映射支持，则通过 map.entry 的值更改” https://docs.oracle.com/ en/java/javase/17/docs/api/java.base/java/util/map.entry.html＃setValue（v）“ rel =“ nofollow noreferrer”> setValue 方法将在背景图中可见。此类 map.entry 实例的行为是在地图入门集视图的迭代之外未定义的。

未定义的行为并不排除执行预期的事情，在实践中，当地图为 hashmap 或 treemap 时，只要您不修改该实例地图（以不同的方式与调用 setValue 在条目上）。

问题是您是否要在这种实施特定的行为上构建应用程序，尽管长期以来尚未明确指定该应用程序。

---

还有另一个问题是，您将这些条目用作另一个地图中的键。条目的平等是由密钥和价值的组合确定的，但不是相关的映射。换句话说，如果不同地图的两个条目恰好具有相同的密钥和价值，那么您会发生冲突，并尝试将另一个条目放置在已经存在的条目中，但将其与新值相关联，而不是针对此条目（或更精确，不适合此目标图）。

更糟糕的是，您正在通过在输入实例中用作密钥时更改平等，通过在它们上调用 setValue ，绝对是非法的，然后将 hashmap 转换为一个不一致的状态：

注意：如果将可变的物体用作地图键，则必须谨慎行事。如果对象的值以影响 equals 比较的方式更改对象的值时，未指定地图的行为。

如果您要做的一切，就是要迭代 tmp 一次，就不需要使用地图，因为不需要查找操作。 list＆lt; map.entry＆lt; key，value＆gt;＆gt; 将做代替 map＆lt; key，value＆gt; ，以保持密钥和值的组合，您可以迭代遍历。实际上，可以使用任何能够持有两个值的对象代替 map.entry＆lt; key，value＆gt; 。如果将其替换为能够持有三个值的对象，则可以跟踪目标地图，键和新值，然后在末尾执行简单的 put 。

因此，第一种方法可以看起来

void recursivePerilousProcedure(Map<String,Object> someMap,
                                List<Map.Entry<Map.Entry<String,Object>,Object>> tmp)
                                throws Exception {
    for(Map.Entry<String,Object> entry1: someMap.entrySet()) {
        Object val = entry1.getValue();
        if (val instanceof Map) {
            recursivePerilousProcedure((Map<String,Object>)val, tmp);
        } else {
            Object newval = performPerilousProcedure(val);
            tmp.add(new AbstractMap.SimpleEntry<>(entry1, newval));
        }
    }
}
void doit(Map<String,Object> someMap) throws Exception {
    List<Map.Entry<Map.Entry<String,Object>,Object>> tmp = new ArrayList<>();

    // Try to process map of entries and record new values
    recursivePerilousProcedure(someMap, tmp);

    // All entries success processed, now simply assign new vals
    // relies on Map implementation detail
    for(Map.Entry<Map.Entry<String,Object>,Object> entry: tmp) {
        Object newval = entry.getValue();
        entry.getKey().setValue(newval); // assign new value
    }
}

依赖于实现细节，但是在调用 setValue 时，不需要地图查找。或干净的解决方案：

record NewValue(Map<String,Object> target, String key, Object newValue) {
    void apply() {
        target.put(key, newValue);
    }
}
void recursivePerilousProcedure(Map<String,Object> someMap,
                                List<NewValue> tmp) throws Exception {
    for(Map.Entry<String,Object> entry1: someMap.entrySet()) {
        Object val = entry1.getValue();
        if (val instanceof Map) {
            recursivePerilousProcedure((Map<String,Object>)val, tmp);
        } else {
            Object newval = performPerilousProcedure(val);
            tmp.add(new NewValue(someMap, entry1.getKey(), newval));
        }
    }
}
void doit(Map<String,Object> someMap) throws Exception {
    List<NewValue> tmp = new ArrayList<>();
    // Try to process map of entries and record new values
    recursivePerilousProcedure(someMap, tmp);

    // All entries success processed, now simply assign new vals
    // assign all new values, cleanly
    tmp.forEach(NewValue::apply);
}

根据您的应用程序，可能有第三种选择。只需在递归处理过程中构建一个与预期目标结构匹配的新地图，即可在未发生错误时替换原始图。

Answer 2

如果我跟随，您可以做这样的事情：

for (Entry<String, Object> entry : someMap.entrySet()) {
    Object newVal = performPerilousProcedure(entry.getValue());
    tmp.put(entry.getKey(), newVal);
}
    
someMap.putAll(tmp);