CODEWITHSUNDEEP
javalambdajava-stream
Wil Selwood
Wil Selwood

Reputation: 1102

Java 8 stream map on entry set

I'm trying to perform a map operation on each entry in a Map object.

I need to take a prefix off the key and convert the value from one type to another. My code is taking configuration entries from a Map<String, String> and converting to a Map<String, AttributeType> (AttributeType is just a class holding some information. Further explanation is not relevant for this question.)

The best I have been able to come up with using the Java 8 Streams is the following:

private Map<String, AttributeType> mapConfig(Map<String, String> input, String prefix) {
   int subLength = prefix.length();
   return input.entrySet().stream().flatMap((Map.Entry<String, Object> e) -> {
      HashMap<String, AttributeType> r = new HashMap<>();
      r.put(e.getKey().substring(subLength), AttributeType.GetByName(e.getValue()));
      return r.entrySet().stream();
   }).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
}

Being unable to construct an Map.Entry due to it being an interface causes the creation of the single entry Map instance and the use of flatMap(), which seems ugly.

Is there a better alternative? It seems nicer to do this using a for loop:

private Map<String, AttributeType> mapConfig(Map<String, String> input, String prefix) {
   Map<String, AttributeType> result = new HashMap<>(); 
   int subLength = prefix.length(); 
   for(Map.Entry<String, String> entry : input.entrySet()) {
      result.put(entry.getKey().substring(subLength), AttributeType.GetByName( entry.getValue()));
   }
   return result;
}

Should I avoid the Stream API for this? Or is there a nicer way I have missed?

Upvotes: 76

Views: 164180

Answers (6)

M. Justin
M. Justin

Reputation: 21074

On Java 9 or later, Map.entry can be used, so long as you know that neither the key nor value will be null. If either value could legitimately be null, AbstractMap.SimpleEntry (as suggested in another answer) or AbstractMap.SimpleImmutableEntry are good alternatives.

private Map<String, AttributeType> mapConfig(
            Map<String, String> input, String prefix) {
    int subLength = prefix.length();
    return input.entrySet().stream().map(e -> Map.entry(
            e.getKey().substring(subLength),
            AttributeType.GetByName(e.getValue())
    )).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
}

That being said, in this particular case, there's no real value in the interim Entry object, and it would be more idiomatic to perform the key/value mapping within Collectors.toMap (as demonstrated in this other answer). However, there are legitimate reasons to create interim entry objects, so it's still helpful to know.

Upvotes: 11

Dawid Pancerz
Dawid Pancerz

Reputation: 301

You could simply use AbstractMap.SimpleEntry<> as follows:

private Map<String, AttributeType> mapConfig(
    Map<String, String> input, String prefix) {
       int subLength = prefix.length();
       return input.entrySet()
          .stream()
          .map(e -> new AbstractMap.SimpleEntry<>(
               e.getKey().substring(subLength),
               AttributeType.GetByName(e.getValue()))
          .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

Any other Pair-like value object would work too (e.g. the Apache Commons Pair tuple).

Upvotes: 30

user_3380739
user_3380739

Reputation: 1244

Here is a shorter solution by abacus-common

Stream.of(input).toMap(e -> e.getKey().substring(subLength), 
                       e -> AttributeType.GetByName(e.getValue()));

Upvotes: -1

M. Justin
M. Justin

Reputation: 21074

As an alternative to using the built-in Java stream support, the StreamEx library could be used. It has fluent support for streams of Entry objects by way of the EntryStream class:

private Map<String, String> mapConfig(Map<String, Integer> input, String prefix) {
    int subLength = prefix.length();
    return EntryStream.of(input)
            .mapKeys(key -> key.substring(subLength))
            .mapValues(AttributeType::GetByName)
            .toMap();
}

Upvotes: 1

Smutje
Smutje

Reputation: 18123

Simply translating the "old for loop way" into streams:

private Map<String, String> mapConfig(Map<String, Integer> input, String prefix) {
    int subLength = prefix.length();
    return input.entrySet().stream()
            .collect(Collectors.toMap(
                   entry -> entry.getKey().substring(subLength), 
                   entry -> AttributeType.GetByName(entry.getValue())));
}

Upvotes: 148

L&#243;r&#225;nt Migl&#233;cz
L&#243;r&#225;nt Migl&#233;cz

Reputation: 529

Please make the following part of the Collectors API:

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

Upvotes: 37

Related Questions