LaLa.java

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

class Data {
    Map<String, Set<String>> value;

    public Data() {
        value = new HashMap<>();
    }
}
public class LaLa {

    Set<Data> dataSet;

    /*
    Input
    [
        {
            "1": ["A", "B"],
            "2": ["A", "C", "D"]
        },
        {
            "1": ["A", "C"],
            "3": ["D"]
        },
        {
            "1": ["B", "C"],
            "4": ["A"]
        }
    ]

    Output
    {
        "A": ["1", "2", "4"],
        "B": ["1"],
        "C": ["1", "2"],
        "D": ["2", "3"]
    }
     */

    private void putToData(Data data, String key, String... values) {
        Set<String> value = Arrays.stream(values).collect(Collectors.toSet());
        data.value.put(key, value);
    }

    public void initDataSet() {
        dataSet = new HashSet<>();
        Data data = new Data();
        putToData(data, "1", "A", "B");
        putToData(data, "2", "A", "C", "D");
        dataSet.add(data);

        data = new Data();
        putToData(data, "1", "A", "C");
        putToData(data, "3", "D");
        dataSet.add(data);

        data = new Data();
        putToData(data, "1", "B", "C");
        putToData(data, "4", "A");
        dataSet.add(data);
    }

    public void printData() {
        System.out.println("Original data:");
        dataSet.forEach(data -> {
            data.value.forEach((k, v) -> {
                System.out.printf("%s: %s\n", k, v.toString());
            });
            System.out.println("-----");
        });
    }

    public void printSolved(Map<String, Set<String>> solvedData) {
        System.out.println("Solved data:");
        solvedData.forEach((k, v) -> System.out.printf("%s: %s\n", k, v.toString()));
    }

    public Map<String, Set<String>> solve() {
        return dataSet.stream().map(data -> data.value.entrySet().stream()
                .map(e -> e.getValue().stream().map(v -> Collections.singletonMap(v, Stream.of(e.getKey()).collect(Collectors.toSet())))
                        .map(HashMap::new)
                        .reduce((m1, m2) -> {

                         m2.entrySet().forEach(es -> {
                             if (m1.get(es.getKey()) == null) {
                                 m1.put(es.getKey(), es.getValue());
                             } else {
                                 m1.get(es.getKey()).addAll(es.getValue());
                             }
                         });
                         return m1;
                     }).get()
                ).reduce((m1, m2) -> {
                    m2.entrySet().forEach(es -> {
                        if (m1.get(es.getKey()) == null) {
                            m1.put(es.getKey(), es.getValue());
                        } else {
                            m1.get(es.getKey()).addAll(es.getValue());
                        }
                    });
                    return m1;
                }).get()
        ).reduce((m1, m2) -> {
            m2.entrySet().forEach(es -> {
                if (m1.get(es.getKey()) == null) {
                    m1.put(es.getKey(), es.getValue());
                } else {
                    m1.get(es.getKey()).addAll(es.getValue());
                }
            });
            return m1;
        }).get();
    }


    public static void main(String[] args) {
        LaLa lala = new LaLa();
        lala.initDataSet();
        lala.printData();
        Map<String, Set<String>> solved = lala.solve();
        lala.printSolved(solved);
    }
}