Transforming a Map in Java using Java 8 Streams - Segregating Map based on the Value of the Map

Question

I have a Map in Java:

Map<String, Set<EntityObject>> itemGroupsMap

class EntityObject {
  boolean isParent;
  String groupId;
}

Now I want to transform itemGroupsMap Map ---to ---:

Map<EntityObject, Set<EntityObject>> parentChildMap.

The logic to do is that each entry of itemGroupsMap -> Set -> Among this Set will an EntityObject that will be a parent (EntityObject.isParent=1). So for each entry in the map I have to find the parent EntityObject and make it key of the parentChildMap and put only the rest of the entitiObjects as the Set/List to this key.

I have tried using 2 foreach loops and I am pretty new to Java 8 so was looking how I can reduce my code using streams?

I looked at Collectors.partitioningBy but it creates 2 maps with 0, 1 keys. I dont really need that.

Any suggestions?

Answer 1

Maybe something like this:

Map<EntityObject, Set<EntityObject>> newMap = itemGroupsMap.entrySet().stream()
        .collect(Collectors.toMap(
                entry -> entry.getValue().stream().filter(value -> value.isParent).findFirst().orElse(null),
                Map.Entry::getValue
        ));

Note: his code doesn't care about data set in initial map without parent -> entry.getValue().stream().filter(value -> value.isParent).findFirst().orElse(null), it tells: set null as a key when no parents in set. So, if it is possible, then every set without parent will be overwritting by the next one without parent.

Answer 2

Here are several approaches, assuming I understand what you want. If the key of the map is EntityObject, then it needs to override equals to take care of duplicate keys which are not allowed. This could be done by using the Id as part of the equals implementation (which isn't obvious from the class provided)

            Map<EntityObject, Set<EntityObject>> parentChildMap =
                itemGroupsMap.entrySet().stream()
                        .collect(Collectors.toMap(
                                // get the single parent object and use
                                // as a key
                                e -> e.getValue().stream()
                                        .filter(o -> o.isParent)
                                        .findFirst().get(),
                                // get the value and remove the parent
                                // key, convert to a set and use as the new
                                // value.
                                e -> e.getValue().stream()
                                        .filter(o -> !o.isParent)
                                        .collect(
                                                Collectors.toSet())));

There may be a better way to do it with streams but I prefer the following as it is straight forward.

        // create the map
        Map<EntityObject, Set<EntityObject>> parentChildMap = new HashMap<>();

        for (Entry<String, Set<EntityObject>> e : itemGroupsMap
                .entrySet()) {

            // get the set of EntityObjects
            Set<EntityObject> eoSet = e.getValue();

            // get the parent one
            EntityObject parentObject = eoSet.stream()
                    .filter(eo->eo.isParent).findFirst().get();

            // remove the parent one from the set
            eoSet.remove(parentObject);

            // add the parentObject and the set to the map
            parentChildMap.put(parentObject,eoSet);
        }