Meine 3D-Map

[Friedvol]

Hallo. Ich versuche gerade, die adder-Funktion zu vereinfachen... Könnte mir dabei bitte jemand behilflich sein?

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;

public class MyCollection {
    private record Elem(int i, int j, String s) {
    }

    private static final HashMap<Integer, HashMap<Integer, ArrayList<String>>> map = new HashMap<>();
    private static final Function<Elem, ArrayList<String>> adder = e -> {
        if (map.containsKey(e.i)) {
            var map2 = map.get(e.i);
            if (map2.containsKey(e.j)) {
                var list = map2.get(e.j);
                list.add(e.s);
                return list;
            }
            var list = new ArrayList<>(List.of(e.s));
            map2.put(e.j, list);
            return list;
        }
        var list = new ArrayList<>(List.of(e.s));
        map.put(e.i, new HashMap<>(Map.of(e.j, list)));
        return list;
    };

    public static void main(String[] args) {
        var e = new Elem(1, 2, "Hello");
        System.out.println(adder.apply(e));
        System.out.println(adder.apply(e));
        e = new Elem(2, 1, "World");
        System.out.println(adder.apply(e));
        System.out.println(adder.apply(e));
        e = new Elem(1, 2, "!");
        System.out.println(adder.apply(e));
        System.out.println(map);
    }
}

 

[KonradN]

Map::computeIfAbsent kannst Du verwenden, ein neues Element zu erzeugen, wenn ein Element nicht vorhanden ist.

Somit wäre die Logik einfach ohne verschachtelte if Statements zu bauen, in dem du halt jeweils im map.computeIfAbsent den Eintrag holst oder eben alternativ neu anlegst.

Ansonsten ist die Frage, wieso Du so eine Variable adder brauchst und nicht einfach direkt eine Methode machst, die du aufrufst. Und die Methode kannst Du dann ja per Methodenreferenz auch nutzen... Lambda Expressions über mehrere Zeilen sind halt nicht gut lesbar. Und auch die Veränderung der map Instanz ist auch nicht gerade gut.

Aber ich vermute einen neuen Account von Tobias?

Edit: Bewertung Lambda Expression angepasst.

 

[Friedvol]

Kannst du Code bereitstellen? Ich verstehe deine Antwort nicht.

 

[Friedvol]

Geschafft!

import java.util.ArrayList;
import java.util.HashMap;
import java.util.function.Function;

public class MyCollection {
    private record Elem(int i, int j, String s) {
    }

    private static final HashMap<Integer, HashMap<Integer, ArrayList<String>>> map = new HashMap<>();
    private static final Function<Elem, ArrayList<String>> adder = e -> {
        map.computeIfAbsent(e.i, k -> new HashMap<>()).computeIfAbsent(e.j, k -> new ArrayList<>()).add(e.s);
        return map.get(e.i).get(e.j);
    };

    public static void main(String[] args) {
        var e = new Elem(1, 2, "Hello");
        System.out.println(adder.apply(e));
        System.out.println(adder.apply(e));
        e = new Elem(2, 1, "World");
        System.out.println(adder.apply(e));
        System.out.println(adder.apply(e));
        e = new Elem(1, 2, "!");
        System.out.println(adder.apply(e));
        System.out.println(map);
    }
}

Aber leider kein Einzeiler und schlechta lesbar 🙈

 

[KonradN]

Man kann ja Code auch lesbar gestalten. Möglichkeiten gibt es viele wie

• den Code aufteilen in mehrere Zeilen
• den Code aufteilen in mehrere Methoden
• den Code Objektorientiert gestalten
• ….

Das Ziel Code kürzer zu gestalten auf Grund der reinen Code Länge ist einfach dumm.

Statt also eine Map mit einer Map als value könnte man da zwei Klassen sehen. Dann wäre es außen nur noch ein lesbarer add Aufruf.
In der add Methode wäre dann nur noch ein relativ lesbarer Map.computeIfAbsent Aufruf (der eine Instanz der zweiten Klasse erzeugt) und mit dem eigentlichen add beim value.
Und das wäre bei der zweiten Klasse in der add Methode ähnlich. Also viel mehr Zeilen Code aber mehrere gut verständliche Klassen und Methoden diealle kurz, übersichtlich, testbar, …. sind.

 

[Robert Zenz]

Also wenn es dir um Lesbarkeit geht, dann ist es immer besser keine Lambdas zu verwenden, sondern stattdessen Methoden Referenzen.

    private static final Map<Integer, Map<Integer, List<String>>> map = new HashMap<>();
    private static final Function<Element, List<String>> adder = MyCollection::addElement;
    
    private static final List<String> addElement(Element element) {
        Map<Integer, List<String>> innerMap = map.computeIfAbsent(
                Integer.valueOf(element.innerMapKey),
                MyCollection::createInnerMap);
        
        List<String> innerList = innerMap.computeIfAbsent(
                Integer.valueOf(element.innerListKey),
                MyCollection::createInnerList);
        
        innerList.add(element.value);
        
        return innerList;
    }
    
    private static final List<String> createInnerList(Integer key) {
        return new ArrayList<>();
    }
    
    private static final Map<Integer, List<String>> createInnerMap(Integer key) {
        return new HashMap<>();
    }