Java 如何在Kotlin中的嵌套Hashmap迭代中使用'filterValues'？

我正在尝试使用Kotlin以更具功能性的风格遍历嵌套Hashmap。特别是，我有两个HashMap实例（都是

Map

）并且我希望根据一些条件匹配它们的值。以下是我想要实现的Java方法：

Map<Integer, Integer> pairs = new LinkedHashMap<>();
for (Map.Entry<String, Integer> oldImages : startingImageMap.entrySet()) {
    for (Map.Entry<String, Integer> newImages : finalImageMap.entrySet()) {
        Integer oldImageVal = oldImages.getValue();
        Integer newImageVal = newImages.getValue();

        boolean containsNewType = pairs.containsKey(newImageVal) &&
                pairs.get(newImageVal).intValue() == oldImageVal.intValue();

        boolean urlsMatch = newImages.getKey().equals(oldImages.getKey());

        if (!containsNewType && urlsMatch) {
            pairs.put(oldImageVal, newImageVal);
        }
    }
}

return pairs;

Map pairs=newlinkedhashmap（）；
对于（Map.Entry oldImages:startingImageMap.entrySet（））{
对于（Map.Entry newImages:finalimageap.entrySet（））{
整数oldImageVal=oldImages.getValue（）；
整数newImageVal=newImages.getValue（）；
布尔containsNewType=pairs.containsKey（newImageVal）&&
pairs.get（newImageVal.intValue（）==oldImageVal.intValue（）；
布尔urlsMatch=newImages.getKey（）.equals（oldImages.getKey（））；
如果（！containsNewType&&urlsMatch）{
pairs.put（oldImageVal、newImageVal）；
}
}
}
返回对；

以下是我在Kotlin中对功能等效的尝试：

private val swapPairs: Map<Int, Int>
    get() {
        val pairs = LinkedHashMap<Int, Int>()

        startingImageMap.forEach {
            val finalImageMap = finalImageMap.filterValues {
                val containsNewType = pairs.containsKey(it) && pairs[it] == startingImageMap[it]
                val urlMatch = it == startingImageMap[it]

                return !containsNewType && urlsMatch
            }.values.first()     
        }
        return pairs
    }

private-val-swapPairs:Map
得到（）{
val pairs=LinkedHashMap（）
startingImageMap.forEach{
val finalimageap=finalimageap.filterValues{
val containsNewType=pairs.containsKey（it）和pairs[it]==startingImageMap[it]
val urlMatch=it==startingImageMap[it]
return！containsNewType&&urlsMatch
}.values.first（）
}
返回对
}

我被困在如何使用

filterValues

正确地执行此操作上。

---

Kotlin中正确的解决方案是什么样子的？

这里的问题是这是一个有状态的过滤器，这意味着将元素放入最终结果的决定取决于之前处理的元素。函数过滤器应该是无状态的，因此无论元素的处理顺序如何，添加元素的决定都是相同的

然而，我认为整个逻辑有点冗长

您可以像这样重写Java版本：

Map<Integer, Integer> pairs = new LinkedHashMap<>();

for (Map.Entry<String, Integer> oldImages : startingImageMap.entrySet()) {
  Integer oldImageVal = oldImages.getValue();
  Integer newImageVal = finalImageMap.get(oldImages.getKey());

  if (newImageVal != null) {
    boolean containsNewType = pairs.containsKey(newImageVal) &&
        pairs.get(newImageVal).intValue() == oldImageVal.intValue();

    if (!containsNewType) {
      pairs.put(oldImageVal, newImageVal);
    }
  }
}

return pairs;

你能加上预期的结果吗？我觉得这个功能有缺陷

   old       new
  A: 1       A: 5
  B: 2       B: 2
  C: 3       C: 3
  D: 4       E: 8
  H: 9       F: 9
             G: 3