Comment puis-je éviter de répéter le code initialisant un hashmap de hashmap?

Chaque client a un identifiant, et de nombreuses factures, avec des dates, stockées sous forme de Hashmap de clients par identifiant, d'un hashmap de factures par date:

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);
}

La solution Java semble être d'utiliser getOrDefault:

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

Mais si get n'est pas nul, je veux toujours que put (date, facture) s'exécute, et l'ajout de données à "allInvoicesAllClients" est toujours nécessaire. Cela ne semble donc pas beaucoup aider.

C'est un excellent cas d'utilisation pour Map#computeIfAbsent. Votre extrait est essentiellement équivalent à:

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

S'il idn'est pas présent en tant que clé allInvoicesAllClients, il créera un mappage de idvers un nouveau HashMapet retournera le nouveau HashMap. Si idest présent sous forme de clé, il renverra l'existant HashMap.

computeIfAbsentest une excellente solution pour ce cas particulier. En général, je voudrais noter ce qui suit, car personne ne l'a encore mentionné:

La table de hachage "externe" stocke simplement une référence à la table de hachage "intérieure", vous pouvez donc simplement réorganiser les opérations pour éviter la duplication de code:

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

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

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

Vous ne devriez pratiquement jamais utiliser l'initialisation de carte "double accolade".

{{  put(date, invoice); }}

Dans ce cas, vous devez utiliser computeIfAbsent

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

S'il n'y a pas de carte pour cet ID, vous en insérerez une. Le résultat sera la carte existante ou calculée. Vous pouvez ensuite putajouter des éléments dans cette carte avec la garantie qu'elle ne sera pas nulle.

C'est plus long que les autres réponses, mais à mon humble avis beaucoup plus lisible:

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

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

Vous faites deux choses distinctes ici: vous assurer que le HashMapexiste et y ajouter la nouvelle entrée.

Le code existant s'assure d'insérer le nouvel élément avant d'enregistrer la carte de hachage, mais ce n'est pas nécessaire, car le HashMapne se soucie pas de l'ordre ici. Aucune des deux variantes n'est threadsafe, donc vous ne perdez rien.

Ainsi, comme l'a suggéré @Heinzi, vous pouvez simplement diviser ces deux étapes.

Ce que je ferais aussi, c'est décharger la création de HashMapl' allInvoicesAllClientsobjet vers l' objet, donc la getméthode ne peut pas revenir null.

Cela réduit également la possibilité de courses entre des threads séparés qui pourraient à la fois obtenir des nullpointeurs getet ensuite décider d' putune nouvelle HashMapavec une seule entrée - la seconde putrejetterait probablement la première, perdant l' Invoiceobjet.