Convert type X to Y in Map> using Java Stream API

Question

I want to convert inner map from map of maps.

Old map: Map<String, Map<LocalDate, Integer>> Integer means seconds

New map: Map<String, Map<LocalDate, Duration>>

I have tried created new inner map, but got an error

Error: java: no suitable method found for putAll(java.util.stream.Stream<java.lang.Object>) method java.util.Map.putAll(java.util.Map<? extends java.time.LocalDate,? extends java.time.Duration>) is not applicable

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())))
                    );
                }}
            ));

related question: https://stackoverflow.com/questions/25864559/iterate-though-a-map-of-maps-with-lambda-in-java-8 — Andrei Epure, May 31 '17 at 11:18
Related (from same OP): [How to get a custom type instead of Integer when using Collectors.summingInt?](https://stackoverflow.com/questions/44285623/how-to-get-a-custom-type-instead-of-integer-when-using-collectors-summingint) — Didier L, May 31 '17 at 19:18

score 11 · Answer 1 · answered May 31 '17 at 11:41

If you want compact code, you may use

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))));

If you want to avoid unnecessary hash operations, you may expand it a bit

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)));
});

the way you chained this... took a while to get it. nice – Eugene May 31 '17 at 13:38 — Eugene, May 31 '17 at 13:38

score 8 · Answer 2 · answered May 31 '17 at 11:41

8

Quick and clean

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);
});

answered May 31 '17 at 11:41

Andrei Epure

1,746
1
21
30

@Holger You were faster, sort answer by oldest. – Alex78191 May 31 '17 at 11:50
1

9 seconds, life is a race :) – Andrei Epure May 31 '17 at 14:34

score 5 · Answer 3 · answered May 31 '17 at 11:46

5

And one more...

 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())))));

answered May 31 '17 at 11:46

Eugene

117,005
15
201
306

@Alex78191 indeed, really close to that! – Eugene May 31 '17 at 11:50
The main idea from the [first answer](https://stackoverflow.com/a/44283570/4854931) – Alex78191 May 31 '17 at 11:53
@Alex78191 It might be, I haven't looked at those. – Eugene May 31 '17 at 11:54

score 5 · Answer 4 · answered May 31 '17 at 14:10

My two cents, create a method to transform Map<K, V1> to a 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));
}

Then your code becomes:

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

holi-java · Answer 5 · 2017-05-31T15:20:30.080

Let's extract a helper method toMap to makes the problem more simpler.

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 you can simplified the code as further since the primary logic is duplicated: adapts a value to another value in a 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));
}

THEN you can use it anywhere that needs a Function<Map<?,?>,Map<?,?>> to adapts the value to another value,for example:

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

score 3 · Answer 6 · edited May 31 '17 at 19:42

3

I would prefer to iterate over the entries of your old map and streaming over the inner map:

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);
}

Otherwise you need a second stream inside your 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())))));

edited May 31 '17 at 19:42

m7913d

10,244
7
28
56

answered May 31 '17 at 11:30

Stefan Warminski

1,845
1
9
18

The main idea of second variant from the [first answer](https://stackoverflow.com/a/44283570/4854931) – Alex78191 May 31 '17 at 11:58
@Alex78191 yeah, he was a bit faster – Stefan Warminski May 31 '17 at 12:00

dabaicai · Answer 7 · 2017-05-31T11:52:59.813

If i understand you correct,you can see following code:

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;
                    })

            );

score 3 · Answer 8 · answered May 31 '17 at 19:15

3

For completeness, here's a version that uses Guava's Maps.transformValues:

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

answered May 31 '17 at 19:15

fps

33,623
8
55
110

I have forgot it. thanks for reminding. I already refactoring my answer that seems to looks like as yours, but someone already answered my idea at the same time. so I adds another usage of `map(Function)`. – holi-java May 31 '17 at 20:08
@holi-java hi! I upvoted your answer. I like it to apply a function to lazily transform the values. – fps May 31 '17 at 20:11
thanks, sir. but I want to say that the final way as yours is better in this case. – holi-java May 31 '17 at 20:17
1

@holi-java oh, thank you very much! Guava is so practical and elegant. Though it's not exactly the same as in your answer, because guava returns a map view. The functions are applied lazily, i.e. when accessing the methods of the map view. – fps May 31 '17 at 20:24
1

yes, sir. the actual mapping occurs in each `get(?)` at runtime, so it doesn't copy a `Map` to another `Map` just is referred a `Map` in wrapper class. – holi-java May 31 '17 at 20:31

user_3380739 · Answer 9 · 2017-06-05T04:54:32.253

1

Here is solution by StreamEx:

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

edited Jun 05 '17 at 04:54

answered Jun 05 '17 at 04:38

user_3380739

1
14
14

Convert type X to Y in Map> using Java Stream API

9 Answers9