Java：从“ Multimap”中创建“ List”

Question

I want to arrange values in Multimap in a ordered List . Where in all the key will be at the left side and all the values will be at right side. I have used recursion to achieve this. But for that I have to pass List to that recursive function which returns void but the List gets modified in that function which I don't like, is there any way to improve this?

Following is my example code

private static void getChilds(String col, List<String> list, Multimap<String, String> map) {
        list.add(col);
        Collection<String> String = map.get(col);
        if (!String.isEmpty()) {
            String.stream().forEach(col1 -> getChilds(col1, list, map));
        }
    }

    private static List<String> getList(Multimap<String, String> map) {
        Set<String> strings = map.keySet();
        List<String> list = new ArrayList<>();
        for (String string : strings) {
            if (!map.containsValue(string)) {
                getChilds(string, list, map);
            }
        }
        return list;
    }


    public static void main(String[] args) {
        ArrayListMultimap<String, String> map = ArrayListMultimap.create();
        map.put("P1", "P2");
        map.put("P1", "P3");
        map.put("P1", "P4");
        map.put("P3", "P5");
        map.put("P3", "P6");
        map.put("P7", "P8");
        map.put("P7", "P9");
        System.out.println(getList(map));
    }

Output : [P1, P2, P3, P5, P6, P4, P7, P8, P9]

Please suggest if there is any nice way with which I will not break any principle of clean code and still get the desired result.

Update

So if we put a new entry in the map like

map.put("P10", "P1");

then corresponding change in the output would be

Output : [P7, P8, P9, P10, P1, P2, P3, P5, P6, P4]

Answer 1

All the keys on the left and all the values on the right of the list:

List<String> result = new LinkedList<String>();
for (Entry<String, String> entry : map.entries()) 
{
    if (!result.contains(entry.getValue()))
    {
        result.addLast(entry.getValue());
    }
    if (!result.contains(entry.getKey()))
    {
        result.addFirst(entry.getKey());
    }
}

If you don't like that list get's modified inside a method. Before issuing that method create a copy of that list and pass a copy instead of original.

List<String> copy = new ArrayList<>(original);

Answer 2

Recursion is a terrible solution for most problems; including this one.

Try a non-clown solution (assuming guava multimap):

Set<String> keySet = multiMap.keySet();
List<String> returnValue = new LinkedList<String>();

for (String currentKey : keySet)
{
    Collection<String> values = multiMap.get(currentKey);
    returnValue.add(currentKey);
    returnValue.addAll(values);
}

Answer 3

I think in a case like this, using an in-out parameter like list could be justified if it makes the overall process more readable, and/or provides performance advantages (fewer memory allocations). A 'clean' approach where each getChilds() call returns a fresh list which the caller then combines with the others, comes at the price of additional memory allocations and copies.

The alternative, if you insist on using streams, could maybe be to use mapTo().reduce() on the stream: let getChilds() return a fresh List, and let reduce() combine them all into one.

Personally, if I were to write getChilds() as a function, I'd write a normal loop here and accumulate the results by hand:

private static List<String> getChilds(String col, Multimap<String, String> map) {
    List<String> list = new ArrayList<>();
    list.add(col);
    Collection<String> values = map.get(col);
    for (String val : values) {
        list.addAll(getChilds(val, map);
    }
    return list;
}

Note: This code is not safe against cycles.

But code style aside: @DwB raises the good point that by collapsing the whole map into a single flat list, you lose all information about the actual key->(value...) relations. The output "[ P8, P6, P4, P5]" can be produced by "P8 -> (P6), P4 -> (P5)", or by "P8 -> (P6, P4, P5)". The code can be made nicer, but is the result in its current form actually useful?

Answer 4

    private static List<String> getChilds(String col, Multimap<String, String> map) {
        List<String> list = new ArrayList<>();
        list.add(col);
        map.get(col).forEach(s->list.addAll(getChilds(s,  map)));
        return list;
    }

    private static List<String> getList(Multimap<String, String> map) {
        Set<String> strings = map.keySet();
        List<String> list = new ArrayList<>();
        for (String string : strings) {
            if (!map.containsValue(string)) {
                list.addAll(getChilds(string, map));
            }
        }
        return list;
    }


    public static void main(String[] args) {
        ArrayListMultimap<String, String> map = ArrayListMultimap.create();
        map.put("P1", "P2");
        map.put("P1", "P3");
        map.put("P1", "P4");
        map.put("P3", "P5");
        map.put("P3", "P6");
        map.put("P7", "P8");
        map.put("P7", "P9");
        map.put("P10", "P1");
        System.out.println(getList(map));
    }