Wie kann ich vermeiden, dass Code wiederholt wird, der eine Hashmap von Hashmap initialisiert?

Jeder Kunde hat eine ID und viele Rechnungen mit Datumsangaben, die als Hashmap von Kunden nach ID gespeichert sind, sowie eine Hashmap von Rechnungen nach Datum:

HashMap<LocalDateTime, Invoice> allInvoices = allInvoicesAllClients.get(id);

if(allInvoices!=null){
    allInvoices.put(date, invoice);      //<---REPEATED CODE
}else{
    allInvoices = new HashMap<>();
    allInvoices.put(date, invoice);      //<---REPEATED CODE
    allInvoicesAllClients.put(id, allInvoices);
}

Java-Lösung scheint zu verwenden getOrDefault:

HashMap<LocalDateTime, Invoice> allInvoices = allInvoicesAllClients.getOrDefault(
    id,
    new HashMap<LocalDateTime, Invoice> (){{  put(date, invoice); }}
);

Aber wenn get nicht null ist, möchte ich immer noch put (Datum, Rechnung) ausführen, und das Hinzufügen von Daten zu "allInvoicesAllClients" ist weiterhin erforderlich. Es scheint also nicht viel zu helfen.

Dies ist ein ausgezeichneter Anwendungsfall für Map#computeIfAbsent. Ihr Snippet entspricht im Wesentlichen:

allInvoicesAllClients.computeIfAbsent(id, key -> new HashMap<>()).put(date, invoice);

Wenn ides nicht als Schlüssel vorhanden ist allInvoicesAllClients, wird eine Zuordnung von idzu einer neuen erstellt HashMapund die neue zurückgegeben HashMap. Wenn ides als Schlüssel vorhanden ist, wird der vorhandene zurückgegeben HashMap.

computeIfAbsentist eine großartige Lösung für diesen speziellen Fall. Im Allgemeinen möchte ich Folgendes beachten, da es noch niemand erwähnt hat:

Die "äußere" Hashmap speichert nur einen Verweis auf die "innere" Hashmap, sodass Sie die Operationen einfach neu anordnen können, um die Codeduplizierung zu vermeiden:

HashMap<LocalDateTime, Invoice> allInvoices = allInvoicesAllClients.get(id);

if (allInvoices == null) {           
    allInvoices = new HashMap<>();
    allInvoicesAllClients.put(id, allInvoices);
}

allInvoices.put(date, invoice);      // <--- no longer repeated

Sie sollten so gut wie nie die "Double Brace" -Karteninitialisierung verwenden.

{{  put(date, invoice); }}

In diesem Fall sollten Sie verwenden computeIfAbsent

allInvoicesAllClients.computeIfAbsent(id, (k) -> new HashMap<>())
                     .put(date, allInvoices);

Wenn für diese ID keine Karte vorhanden ist, fügen Sie eine ein. Das Ergebnis ist die vorhandene oder berechnete Karte. Sie können dann putElemente in dieser Karte mit der Garantie, dass sie nicht null sind.

Dies ist länger als die anderen Antworten, aber imho weitaus besser lesbar:

if(!allInvoicesAllClients.containsKey(id))
    allInvoicesAllClients.put(id, new HashMap<LocalDateTime, Invoice>());

allInvoicesAllClients.get(id).put(date, invoice);

Sie machen hier zwei verschiedene Dinge: Sicherstellen, dass die HashMap vorhanden ist, und Hinzufügen des neuen Eintrags.

Der vorhandene Code stellt sicher, dass das neue Element zuerst eingefügt wird, bevor die Hash-Map registriert wird. Dies ist jedoch nicht erforderlich, da die HashMap die Reihenfolge hier nicht wichtig ist. Keine der beiden Varianten ist threadsicher, sodass Sie nichts verlieren.

Wie @Heinzi vorgeschlagen hat, können Sie diese beiden Schritte einfach aufteilen.

Was ich auch tun würde, ist die Erstellung des HashMapin das allInvoicesAllClientsObjekt zu verlagern, so dass die getMethode nicht zurückkehren kann null.

Dies verringert auch die Möglichkeit für Rennen zwischen separaten Threads, von denen beide nullZeiger abrufen getund sich dann für puteinen neuen HashMapmit einem einzelnen Eintrag entscheiden könnten - der zweite putwürde wahrscheinlich den ersten verwerfen und das InvoiceObjekt verlieren .