使用 Java Stream API 将 Map<K, Map<V, X>> 中的 X 类型转换为 Y

Question

我想从地图的地图转换内部地图。

旧地图：Map<String, Map<LocalDate, Integer>>整数表示秒

新地图：Map<String, Map<LocalDate, Duration>>

我已尝试创建新的内部地图，但出现错误

错误：java：没有找到适合putAll(java.util.stream.Stream<java.lang.Object>) 的方法 方法java.util.Map.putAll(java.util.Map<? extends java.time.LocalDate,? extends java.time.Duration>)不适用

oldMap.entrySet().stream()
            .collect(Collectors.toMap(Map.Entry::getKey,
                e -> new HashMap<LocalDate, Duration>() {{
                    putAll(
                        e.getValue().entrySet().stream()
                            .map(x -> new HashMap.SimpleEntry<LocalDate, Duration>
                                (x.getKey(), Duration.ofSeconds(x.getValue())))
                    );
                }}
            ));

Answer 1

我更愿意遍历旧地图的条目并在内部地图上流式传输：

for (Entry<String, Map<LocalDate, Integer>> entry : oldMap.entrySet()) {
    Map<LocalDate, Duration> asDuration = entry.getValue().entrySet().stream()
        .collect(Collectors.toMap(e -> e.getKey(), e -> Duration.ofSeconds(e.getValue().longValue())));
    newMap.put(entry.getKey(), asDuration);
}

否则，您需要在 collect 中添加第二个流：

newMap = oldMap.entrySet().stream()
        .collect(Collectors.toMap(s -> s.getKey(), s -> s.getValue().entrySet().stream()
        .collect(Collectors.toMap(e -> e.getKey(), e -> Duration.ofSeconds(e.getValue().longValue())))));

Answer 2

如果我理解正确，您可以看到以下代码：

oldMap.entrySet().stream()
            .collect(Collectors.toMap(x -> x.getKey(),
                    x -> {
                        Map<LocalDate, Duration> temp = new HashMap<>();
                        x.getValue().forEach((k, v) -> {
                            temp.put(k, Duration.ofSeconds(v));
                        });
                        return temp;
                    })

            );

Answer 3

如果你想要紧凑的代码，你可以使用

Map<String, Map<LocalDate, Duration>> newMap = new HashMap<>();
oldMap.forEach((s,o) -> o.forEach((d, i) ->
    newMap.computeIfAbsent(s, x->new HashMap<>()).put(d, Duration.ofSeconds(i))));

如果你想避免不必要的哈希操作，你可以稍微扩展一下

Map<String, Map<LocalDate, Duration>> newMap = new HashMap<>();
oldMap.forEach((s,o) -> {
    Map<LocalDate, Duration> n = new HashMap<>();
    newMap.put(s, n);
    o.forEach((d, i) -> n.put(d, Duration.ofSeconds(i)));
});

Answer 4

快速干净

HashMap<String, HashMap<LocalDate, Duration>> newMap = new HashMap<>();
oldHashMap.forEach((key, innerMap) -> {
    HashMap<LocalDate, Duration> newStuff = new HashMap<>();
    innerMap.forEach((k2,v2) -> newStuff.put(k2,Duration.ofSeconds(v2)));
    newMap.put(key, newStuff);
});

Answer 5

还有一个……

 Map<String, Map<LocalDate, Duration>> newMap = map.entrySet().stream().collect(
            Collectors.toMap(Entry::getKey,
                    entry -> entry.getValue().entrySet().stream().collect(
                            Collectors.toMap(Entry::getKey, e -> Duration.ofSeconds(e.getValue())))));

Answer 6

让我们提取一个辅助方法toMap 以使问题更简单。

Map<String, Map<LocalDate, Duration>> result = oldMap.entrySet().stream()
    .map(entry -> new AbstractMap.SimpleEntry<>(
         entry.getKey(),
         entry.getValue().entrySet().stream()
                         .collect(toMap(it -> Duration.ofSeconds(it.longValue())))
//                                ^--- mapping Integer to Duration
    )).collect(toMap(Function.identity()));



<K, V, R> Collector<Map.Entry<K, V>, ?, Map<K, R>> toMap(Function<V, R> mapping) {
    return Collectors.toMap(
         Map.Entry::getKey,
         mapping.compose(Map.Entry::getValue)
    );
}

AND您可以进一步简化代码，因为主要逻辑是重复的：将一个值调整为 Map 中的另一个值。

Function<
    Map<String, Map<LocalDate, Integer>>,
    Map<String, Map<LocalDate, Duration>>
> mapping = mapping(mapping(seconds -> Duration.ofSeconds(seconds.longValue())));
//          |       |
//          |   adapts Map<LocalDate, Integer> to Map<LocalDate,Duration>
//          | 
//adapts Map<String,Map<LocalDate,Integer>> to Map<String,Map<LocalDate,Duration>>

Map<String, Map<LocalDate, Duration>> result = mapping.apply(oldMap);


<K, V1, V2> Function<Map<K, V1>, Map<K, V2>> mapping(Function<V1, V2> mapping) {
    return it -> it.entrySet().stream().collect(toMap(mapping));
}

那么您可以在任何需要Function<Map<?,?>,Map<?,?>> 将值调整为另一个值的地方使用它，例如：

Map<String, Map<LocalDate, Duration>> result = Optional.of(oldMap)
        .map(mapping(mapping(seconds -> Duration.ofSeconds(seconds.longValue()))))
        .get();

Answer 7

我的两分钱，创建一个将Map<K, V1>转换为Map<K, V2>的方法：

public static <K,V1,V2> Map<K, V2> transformValues(final Map<K, V1> input, final Function<V1,V2> transform) {
    Function<Map.Entry<K, V1>, V2> mapper = transform.compose(Map.Entry::getValue);
    return input.entrySet().stream()
            .collect(toMap(Map.Entry::getKey, mapper));
}

那么你的代码就变成了：

Map<String, Map<LocalDate, Duration>> transformed 
    = transformValues(maps, map -> transformValues(map, Duration::ofSeconds));

Answer 8

为了完整起见，这里有一个使用 Guava 的 Maps.transformValues 的版本：

Map<String, Map<LocalDate, Duration>> result = 
    Maps.transformValues(oldMap, m -> Maps.transformValues(m, Duration::ofSeconds));

Answer 9

这是StreamEx的解决方案：

EntryStream.of(oldMap)
           .mapValues(v -> EntryStream.of(v).mapValues(Duration::ofSeconds).toMap())
           .toMap();