HashMap in Java: put, get, iterare e schemi comuni

Una mappa memorizza coppie chiave-valore

Una HashMap (di java.util) memorizza associazioni: ogni chiave corrisponde a un valore, e cerchi i valori tramite la loro chiave in un tempo circa costante. Pensa a un dizionario: la parola è la chiave, la definizione è il valore.

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        System.out.println(ages.get("Boris"));
        System.out.println(ages);
    }
}

I due parametri di tipo sono <KeyType, ValueType>. Qui le chiavi sono String e i valori sono Integer. Come per ArrayList, di solito dichiari la variabile con l'interfaccia Map e costruisci una HashMap.

put, get e sovrascrittura

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);
        stock.put("apples", 75);   // stessa chiave -> sovrascrive il valore precedente

        System.out.println(stock.get("apples"));  // 75
        System.out.println(stock.get("pears"));    // null: la chiave non esiste
    }
}

Due cose da tenere a mente:

• Una chiave è unica. put con una chiave esistente ne sostituisce il valore e restituisce quello vecchio.
• get su una chiave mancante restituisce null, non un errore. L'unboxing automatico di quel null in un int lancia una NullPointerException, una fonte comune di bug.

getOrDefault evita la trappola del null

Invece di controllare ogni volta se c'è null, chiedi un valore di riserva:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);

        int apples = stock.getOrDefault("apples", 0);
        int pears = stock.getOrDefault("pears", 0);

        System.out.println(apples + " apples, " + pears + " pears");
    }
}

È il modo più pulito per gestire ricerche di valori "forse presenti", e porta direttamente allo schema più famoso della HashMap.

Contare le occorrenze

Contare quante volte compare ogni elemento è il compito da manuale di una HashMap:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        String text = "the cat the dog the cat";
        Map<String, Integer> counts = new HashMap<>();

        for (String word : text.split(" ")) {
            counts.put(word, counts.getOrDefault(word, 0) + 1);
        }

        System.out.println(counts);
    }
}

Lo schema map.put(key, map.getOrDefault(key, 0) + 1) si legge come "prendi il conteggio attuale (o zero), aggiungi uno, rimettilo a posto". Un equivalente più ordinato è counts.merge(word, 1, Integer::sum).

Verificare e rimuovere

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        System.out.println(ages.containsKey("Ada"));     // true
        System.out.println(ages.containsValue(29));      // true
        System.out.println(ages.size());                 // 2

        ages.remove("Ada");
        System.out.println(ages.containsKey("Ada"));     // false
    }
}

putIfAbsent(key, value) scrive solo quando la chiave manca: utile per l'inizializzazione pigra.

Scorrere una HashMap

Il ciclo più comune percorre entrySet(), dandoti insieme ogni chiave e valore:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Se ti servono solo le chiavi o solo i valori:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        for (String name : ages.keySet()) {
            System.out.println(name);
        }
        for (int age : ages.values()) {
            System.out.println(age);
        }
    }
}

Puoi anche usare forEach con una lambda: ages.forEach((name, age) -> System.out.println(name + ": " + age));.

HashMap non mantiene l'ordine

Una HashMap non garantisce alcun ordine di iterazione: è quello prodotto dall'hashing e può cambiare da un'esecuzione all'altra. Se ti serve un ordine prevedibile:

• LinkedHashMap mantiene l'ordine di inserimento.
• TreeMap tiene le chiavi ordinate secondo l'ordine naturale (o secondo un Comparator che fornisci tu).

Tutte e tre implementano l'interfaccia Map, quindi cambiare è una modifica di una riga al costruttore.

Le chiavi devono essere hashabili

HashMap trova le coppie calcolando l'hash della chiave, quindi hashCode() ed equals() di una chiave devono essere coerenti. I tipi predefiniti come String e Integer lo fanno già correttamente. Se usi una tua classe come chiave, fai l'override sia di equals sia di hashCode, altrimenti due oggetti "uguali" nel significato finiranno in bucket diversi e le tue ricerche falliranno in modo misterioso.

Prossimo passo: HashSet

Una HashMap risponde alla domanda "quale valore è memorizzato sotto questa chiave?". Quando ti interessa solo sapere se qualcosa è presente, cioè un insieme di valori unici senza dati associati, lo strumento giusto è HashSet, il prossimo argomento.