Argthtjtr

Consider a piece of code:

imnport reactor.util.context.Context



public Context addAll (Context ctx, Map.Entry<String, Object> hashMap) {

    Context ctxVar = ctx;

    for (Map.Entry<String, Object> e : hashMap.entrySet()) {

        if (e.getValue() != null) {

            ctxVar = ctxVar.put(e.getKey(), e.getValue());

        }

    }

    return ctxVar;

}

reactor.util.context.Context is immutable class. So put merges old context with new added value and returns new
context.

The question is - is there more compact way to "combine" HashMap into immutable object using java 8 streams? (Not for Context class only)

Note: I have read about java stream collect and it seems that does not work because I have to supply initial Context
and combine several contexts after map but recreate entire context for combine operations I think is too much.

You can use reduce:

Context ctxVar = hashMap.entrySet()

                        .stream()

                        .filter(e -> e.getValue() != null)

                        .reduce(ctx,

                                (c, e) -> c.put(e.getKey(), e.getValue()),

                                (c1, c2) -> c1.putAll(c2));

It does seem wasteful, though (in the same way your original loop is wasteful), since it creates multiple Context instances when only the last one is needed.

It would make more sense if you write a static method of the Context class (or a constructor) that accepts a Map and only creates a single Context instance for the entries of the Map. However, I now noticed that you didn't write this Context class, so you can't change it.

Your question interested me. I researched the subject.

Here is what I came up with:

package reactor.util.context;



import java.util.Map;

import java.util.Map.Entry;

import static java.util.stream.Collectors.toMap;



public class ContextUtils {

    public static Context putAll(Context context, Map map) {

        if (map.isEmpty()) {

            return context;

        } else {

            Map contextMap = context.stream()

                                    .filter(e -> e.getValue() != null)

                                    .collect(toMap(Entry::getKey, Entry::getValue));

            return new ContextN(contextMap, map);

        }

    }

}

This utility method creates a new Context containing the entries from both initial context and provided map.

This solution may still look not optimal, as it creates a new HashMap with initiaCapacity = 0 and loadFactor = 0.75f. In fact, this is not a problem, since ContextN itself is a subclass of HashMap with precise capacity and loadFactor = 1. The data from intermediary map will be copied to the context and later it will be collected by GC.

Note: the utility class has to be in package reactor.util.context. ContextN is package-private so it is not accessible from other packages.