Java8: HashMap to HashMap using Stream / Map-Reduce / Collector

Working through transformation cases

As you transform from Y to Z, you'll encounter various situations. Let's dance through the most common ones:

Null management in transformations

Null values are the silent killers of stream operations, but they don't have to be. Provide a default value or a null-safe operation:

// Default values: the silent heroes in the epic battle against NullPointerExceptions
HashMap<X, Z> resultMap = sourceMap.entrySet().stream()
    .collect(Collectors.toMap(
        Map.Entry::getKey, 
        entry -> (entry.getValue() == null ? defaultValue : yourTransformation(entry.getValue()))
    ));


Encouraging reuse with Function Interface

To promote reuse, encapsulate the transformation within a Function<Y, Z>. The Function Interface is not just a pretty face:

// Function Interface walked into a bar... and nothing broke!
Function<Y, Z> transformFunction = y -> // ... define transformation;
HashMap<X, Z> resultMap = sourceMap.entrySet().stream()
    .collect(Collectors.toMap(
        Map.Entry::getKey,
        entry -> transformFunction.apply(entry.getValue())
    ));


Handling complex transformations

Some transformations feel like being lost in a maze, but there's a way out! Break down complex operations into digestible chunks:

// Harry Potter and the Prisoner of HashMap...
HashMap<X, Z> resultMap = sourceMap.entrySet().stream()
    .collect(Collectors.toMap(
        Map.Entry::getKey,
        entry -> complexTransformation(entry.getValue())
    ));


Under the hood of complex cases

When the going gets tough, such as dealing with complex data types or nested structures, we get more creative. Transformation isn't just a spark, but a bonfire:

Taking steps one at a time

When transformation requires several paces, it's best to chain them using the age-old advice, "One step at a time":

// Multi-step transformation: like cooking... but with more hashmap and less burning
HashMap<X, Z> resultMap = sourceMap.entrySet().stream()
    .collect(Collectors.toMap(
        Map.Entry::getKey,
        entry -> firstStep(secondStep(thirdStep(entry.getValue())))
    ));


Error taming in stream transformations

Account for errors or exceptions lurking in the shadows during a transformation. Catch these within your lambda expression:

// Try, catch, transform!
HashMap<X, Z> resultMap = sourceMap.entrySet().stream()
    .collect(Collectors.toMap(
        Map.Entry::getKey,
        entry -> {
            try {
                return transformWithExceptions(entry.getValue());
            } catch (TransformationException e) {
                logError(e); // when life gives you exceptions, make error handling!
                return defaultValue; // or yell "fire!", throwing a unchecked exception
            }
        }
    ));


Flexibility enhancement with wildcards

For a reusable transformation recipe, usage of wildcards (?) in generics can enhance flexibility. A secret ingredient for a robust solution:

// Wildcards: riding the flexibility train!
public <X, Y, Z> HashMap<X, Z> transformMap(HashMap<X, ? extends Y> sourceMap, Function<? super Y, ? extends Z> transformer) {
    return sourceMap.entrySet().stream()
        .collect(Collectors.toMap(
            Map.Entry::getKey,
            entry -> transformer.apply(entry.getValue())
        ));
}


Finessing and alternatives

Sometimes, the best solution needs a little finesse. Here are some alternatives you might consider when transforming HashMaps:

Direct iteration with forEach

For simple cases where streaming feels too much, a forEach can be the cup of tea you're seeking:

// No streaming? No problem!
HashMap<X, Z> resultMap = new HashMap<>();
sourceMap.forEach((key, value) -> resultMap.put(key, yourConversionMethod(value)));


Specialty transformation with external libraries

If you're already dancing with Google Guava, then map transformation is a waltz:

// Dance with Guava: It doesn't step on your toes!
ImmutableMap<X, Z> resultMap = Maps.transformValues(sourceMap, yourConversionFunction::apply);


Lean code with testable transformations

Nothing says clean code like testable transformations. Win the maintainability marathon by making transformations individually testable.