Como evitar a repetição de código inicializando um hashmap de hashmap?

Todo cliente tem um ID e muitas faturas, com datas, armazenadas como Hashmap de clientes por ID, de um hashmap de faturas por data:

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

A solução Java parece usar getOrDefault:

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

Mas se get não for nulo, eu ainda quero que a execução da data (fatura) seja executada, e também é necessário adicionar dados a "allInvoicesAllClients". Portanto, isso não parece ajudar muito.

Este é um excelente caso de uso para Map#computeIfAbsent. Seu snippet é essencialmente equivalente a:

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

Se idnão estiver presente como chave allInvoicesAllClients, ele criará o mapeamento de idpara um novo HashMape retornará o novo HashMap. Se idestiver presente como chave, retornará o existente HashMap.

computeIfAbsenté uma ótima solução para este caso em particular. Em geral, gostaria de observar o seguinte, já que ninguém o mencionou ainda:

O hashmap "externo" apenas armazena uma referência ao hashmap "interno", para que você possa reordenar as operações para evitar a duplicação de código:

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

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

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

Você nunca deve usar a inicialização de mapa com "chave dupla".

{{  put(date, invoice); }}

Nesse caso, você deve usar computeIfAbsent

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

Se não houver um mapa para esse ID, você inserirá um. O resultado será o mapa existente ou computado. Você pode então putitens nesse mapa com garantia de que não será nulo.

Isso é mais longo que as outras respostas, mas é muito mais legível:

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

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

Você está fazendo duas coisas separadas aqui: garantir a existência HashMape adicionar a nova entrada a ela.

O código existente certifica-se de inserir o novo elemento primeiro antes de registrar o mapa de hash, mas isso não é necessário, porque HashMapele não se importa com o pedido aqui. Nenhuma das variantes é segura para threads, portanto você não está perdendo nada.

Então, como o @Heinzi sugeriu, você pode dividir essas duas etapas.

O que eu também faria é descarregar a criação de HashMappara o allInvoicesAllClientsobjeto, para que o getmétodo não possa retornar null.

Isso também reduz a possibilidade de corridas entre segmentos separados, que poderiam obter nullponteiros gete decidir putum novo HashMapcom uma única entrada - a segunda putprovavelmente descartaria a primeira, perdendo o Invoiceobjeto.