Java-8 Streams: Convert Map<String, List<List<DataType>>> to Map<String, List<DataType>>

Question

I've just started looking at Java 8 and trying out lambdas, below is the problem i wanted to solve

Below is the code so far I have

    Map<String, List<List<DataType>>> a = Arrays.stream(OperatorType.values())
            .collect(
                    groupingBy(i -> i.getKey(), 
                            mapping(i -> i.getSupportedtypes(), 
                                    Collectors.toList())));

The above snippet works, but thats not what i want. I want to it to be returning Map<String, List<DataType>>

I am guessing some way of flat mapping will resolve the question

OperatorType enum for reference

 public enum OperatorType {

IS_ONE_OF("IS_ONE_OF", 1,
        Collections.singletonList(DataType.ALL)),
IS_NOT_ONE_OF("IS_NOT_ONE_OF", 2,
        Collections.singletonList(DataType.ALL)),
ENDS_WITH("ENDS_WITH", 3,
        Collections.singletonList(DataType.STRING)),
DOES_NOT_ENDS_WITH("DOES_NOT_ENDS_WITH", 4,
        Collections.singletonList(DataType.STRING)),
STARTS_WITH("STARTS_WITH", 5,
        Collections.singletonList(DataType.STRING)),
DOES_NOT_START_WITH("DOES_NOT_START_WITH", 6,
        Collections.singletonList(DataType.STRING)),
MATCHES("MATCHES", 7,
        Collections.singletonList(DataType.STRING)),
DOES_NOT_MATCH("DOES_NOT_MATCH", 8,
        Collections.singletonList(DataType.STRING)),
CONTAINS("CONTAINS", 9,
        Collections.singletonList(DataType.STRING)),
DOES_NOT_CONTAIN("DOES_NOT_CONTAIN", 10,
        Collections.singletonList(DataType.STRING)),
GREATER_THAN("GREATER_THAN", 11, Arrays.asList(DataType.INTEGER,DataType.DOUBLE)), 
GREATER_THAN_OR_EQUAL_TO("GREATER_THAN_OR_EQUAL_TO", 12, Arrays.asList(DataType.INTEGER,DataType.DOUBLE)), 
LESS_THAN("LESS_THAN", 13, Arrays.asList(DataType.INTEGER,DataType.DOUBLE)),
LESS_THAN_OR_EQUAL_TO("LESS_THAN_OR_EQUAL_TO", 15, Arrays.asList(DataType.INTEGER,DataType.DOUBLE)), 
AFTER("AFTER", 15,
        Collections.singletonList(DataType.DATE)),
BEFORE("BEFORE", 16,
        Collections.singletonList(DataType.DATE));

private final int value;

private final String key;

private final List<DataType> supportedtypes;

OperatorType(String key, int value, List<DataType> supportedtypes) {
    this.value = value;
    this.key = key;
    this.supportedtypes = supportedtypes;
}

public int getValue() {
    return this.value;
}

public String getKey() {
    return this.key;
}

public List<DataType> getSupportedtypes() {
    return this.supportedtypes;
}

@Override
public String toString() {
    return String.valueOf(this.value);
}

@JsonCreator
public static OperatorType create(String key) {
    if (key == null) {
        throw new IllegalArgumentException();
    }
    for (OperatorType v : values()) {
        if (v.getKey().equalsIgnoreCase(key)) {
            return v;
        }
    }
    throw new IllegalArgumentException();
}

public static OperatorType fromValue(Integer value) {

    for (OperatorType type : OperatorType.values()) {
        if (value == type.getValue()) {
            return type;
        }
    }
    throw new IllegalArgumentException("Invalid enum type supplied");
}

public static OperatorType fromValue(String key) {

    for (OperatorType type : OperatorType.values()) {
        if (type.getKey().equalsIgnoreCase(key)) {
            return type;
        }
    }
    throw new IllegalArgumentException("Invalid enum type supplied");
}

}

Found one way to do this:

public static Map<DataType, List<OperatorType>> buildmap() {
    Map<OperatorType, List<DataType>> map = new HashMap<>();

    Arrays.stream(OperatorType.values()).collect(groupingBy(i -> OperatorType.fromValue(i.getKey()),
            mapping(i -> i.getSupportedtypes(), Collectors.toList()))).entrySet().forEach(entry ->
                {
                    map.put(entry.getKey(),
                            entry.getValue().stream().flatMap(List::stream).collect(Collectors.toList()));
                });

    return map.entrySet().stream().flatMap(e -> e.getValue().stream().map(v -> new SimpleEntry<>(v, e.getKey())))
            .collect(
                    Collectors.groupingBy(Entry::getKey, Collectors.mapping(Entry::getValue, Collectors.toList())));
}

Why are you using groupingBy? The "keys" in your enum are all unique — Robin Topper
– Robin Topper, Commented May 1, 2017 at 14:19
I wanted to create a reverse lookup map from the above enum. i.e Map<DataType, List<OperatorType>> , so i thought I create a Map<Operator, List<DataType>>, so that i can achieve the desired result — shoaib1992
– shoaib1992, Commented May 1, 2017 at 14:21
If I understand it correctly, you can use toMap instead of groupingBy — Robin Topper
– Robin Topper, Commented May 1, 2017 at 14:29
I am not sure how toMap can be used in this case as this involves list modification i.e List<DataType> — shoaib1992
– shoaib1992, Commented May 1, 2017 at 14:31
@RobinTopper yes please that would be great. Also please have a look at my approach. Added in the question itself — shoaib1992
– shoaib1992, Commented May 1, 2017 at 16:20

Robin Topper · Accepted Answer · 2017-05-01 17:13:44Z

I've thrown out a few methods and switched out your DataType with Integer in your enum, it now looks like this:

enum OperatorType {
    IS_ONE_OF("IS_ONE_OF", 1,
           Collections.singletonList(1)),
    IS_NOT_ONE_OF("IS_NOT_ONE_OF", 2,
           Collections.singletonList(1)),
    ENDS_WITH("ENDS_WITH", 3,
           Collections.singletonList(2)),
    DOES_NOT_ENDS_WITH("DOES_NOT_ENDS_WITH", 4,
           Collections.singletonList(2)),
    STARTS_WITH("STARTS_WITH", 5,
           Collections.singletonList(2)),
    DOES_NOT_START_WITH("DOES_NOT_START_WITH", 6,
           Collections.singletonList(2)),
    MATCHES("MATCHES", 7,
           Collections.singletonList(2)),
    DOES_NOT_MATCH("DOES_NOT_MATCH", 8,
           Collections.singletonList(2)),
    CONTAINS("CONTAINS", 9,
           Collections.singletonList(2)),
    DOES_NOT_CONTAIN("DOES_NOT_CONTAIN", 10,
           Collections.singletonList(2)),
    GREATER_THAN("GREATER_THAN", 11, Arrays.asList(3,4)), 
    GREATER_THAN_OR_EQUAL_TO("GREATER_THAN_OR_EQUAL_TO", 12, Arrays.asList(3,4)), 
    LESS_THAN("LESS_THAN", 13, Arrays.asList(3,4)),
    LESS_THAN_OR_EQUAL_TO("LESS_THAN_OR_EQUAL_TO", 15, Arrays.asList(3,4)), 
    AFTER("AFTER", 15,
           Collections.singletonList(5)),
    BEFORE("BEFORE", 16,
           Collections.singletonList(5));

    private final int value;

    private final String key;

    private final List<Integer> supportedtypes;

    OperatorType(String key, int value, List<Integer> supportedtypes) {
       this.value = value;
       this.key = key;
       this.supportedtypes = supportedtypes;
    }

    public int getValue() {
       return this.value;
    }

    public String getKey() {
       return this.key;
    }

    public List<Integer> getSupportedtypes() {
       return this.supportedtypes;
    }

    @Override
    public String toString() {
       return String.valueOf(this.value);
    }
}

Should be fairly straightforward to switch your DataType back into the following code:

Map<String,List<Integer>> map = Arrays.stream(OperatorType.values()).collect(Collectors.toMap(OperatorType::getKey, OperatorType::getSupportedtypes));
map.forEach((k,v) -> System.out.println(k + " " + v));
System.out.println("");

Map<Integer,List<OperatorType>> map2 = 
        map.entrySet().stream()
        .flatMap(e -> e.getValue().stream().map(f -> new AbstractMap.SimpleEntry<>(f,e.getKey())))
        .collect(Collectors.groupingBy(r -> r.getKey(), Collectors.mapping(s -> Enum.valueOf(OperatorType.class, s.getValue()), Collectors.toList())));
map2.forEach((k,v) -> System.out.println(k + " " + v));

You can chain these two steps. But for readibility, I've left them separate.

For me the print statements print the following:

DOES_NOT_CONTAIN [2]
STARTS_WITH [2]
LESS_THAN_OR_EQUAL_TO [3, 4]
DOES_NOT_MATCH [2]
AFTER [5]
DOES_NOT_ENDS_WITH [2]
IS_ONE_OF [1]
LESS_THAN [3, 4]
GREATER_THAN_OR_EQUAL_TO [3, 4]
CONTAINS [2]
DOES_NOT_START_WITH [2]
IS_NOT_ONE_OF [1]
BEFORE [5]
GREATER_THAN [3, 4]
ENDS_WITH [2]
MATCHES [2]

1 [2, 1]
2 [7, 3, 6, 9, 4, 8, 5, 10]
3 [11, 12, 13, 15]
4 [11, 12, 13, 15]
5 [16, 15]

I know this answer is lacking some explanation, but it produces the Map<DataType,List<OperatorType>> that you want

shmosel · Accepted Answer · 2017-05-02 05:44:47Z

1

It looks like your keys are identical to the enum name. If that's the case:

a) You don't need the key at all; just use the enum constant's name:

public String getKey() {
    return this.name();
}

b) Since the keys are unique, there's no grouping necessary. Use the toMap() collector instead:

Map<String, List<DataType>> a = Arrays.stream(OperatorType.values())
        .collect(toMap(OperatorType::getKey, OperatorType::getSupportedtypes));

answered May 2, 2017 at 5:44

shmosel

51.1k7 gold badges81 silver badges148 bronze badges

Comments

Jacob G. · Accepted Answer · 2017-05-01 14:10:58Z

0

You should be able to use Stream#flatMap for this:

Map<String, List<DataType>> map = new HashMap<>();

a.entrySet().forEach(entry -> {
    map.put(entry.getKey(), entry.getValue().stream()
                                            .flatMap(List::stream)
                                            .collect(Collectors.toList()));
});

Because the List of Lists in each value of the Map must be condensed, we must first make a new Map and then re-add the elements after condensing each List<List<DataType>>

answered May 1, 2017 at 14:10

Jacob G.

29.8k7 gold badges70 silver badges122 bronze badges

3 Comments

shoaib1992 Over a year ago

is there way not to create the map and achieve this ?

Jacob G. Over a year ago

By that, do you mean collect it directly into a Map<String, List<DataType>>?

Jacob G. Over a year ago

If you use Collectors#toMap, it returns a Map<Object, Object> which would have to be explicitly cast to Map<String, List<Integer>>, which is messy. You could define the reduction generic types, but that would be even messier. Most likely, your best bet would be to use the method above in my answer.

CoronA · Accepted Answer · 2017-05-02 05:22:47Z

0

One way could be to replace the collector toList to a more appropriate one, e.g. reducing:

Map<String, List<DataType>> a = Arrays.stream(OperatorType.values())
  .collect(
    groupingBy(i -> i.getKey(), 
      mapping(i1 -> i1.getSupportedtypes(),
        reducing((List<DataType>) new ArrayList<DataType>(), (l,r) -> {
          List<DataType> list = new ArrayList<DataType>();
          list.addAll(l);
          list.addAll(r);
          return list;
        }))));

For better readability it might be helpful to extract the binary operator function, e.g. (l,r) -> join(l,r), where join concatenates two lists.

edited May 2, 2017 at 5:22

answered May 2, 2017 at 5:17

CoronA

8,1724 gold badges30 silver badges56 bronze badges

Collectives™ on Stack Overflow

Java-8 Streams: Convert Map<String, List<List<DataType>>> to Map<String, List<DataType>>

4 Answers 4

Comments

Comments

3 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

Comments

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related