Java HashMap: la me­mo­riz­za­zio­ne di dati in coppie chiave-valore

Con la classe Java HashMap puoi me­mo­riz­za­re i dati in coppie chiave-valore. Questa fun­zio­na­li­tà ti permette non soltanto di ri­chia­ma­re e gestire più fa­cil­men­te una lista, ma ti offre anche numerose pos­si­bi­li­tà di accesso. Nelle parti seguenti ti pre­sen­tia­mo i prin­ci­pa­li metodi per farlo.

Che cosa sono le HashMap in Java?

Esistono diversi metodi per me­mo­riz­za­re e ri­chia­ma­re i dati. A seconda dell’ap­pli­ca­zio­ne, può essere più adatto un tipo di me­mo­riz­za­zio­ne o un altro. In molti casi, la classe Java HashMap dovrebbe essere la soluzione migliore. Al contrario di altri metodi, questa classe memorizza i dati sotto forma di coppie chiave-valore. Questo sistema prevede che a ogni chiave (Key) sia assegnato esat­ta­men­te un valore (Value). Quando desideri ri­chia­ma­re questo valore, puoi uti­liz­za­re la relativa chiave e ottenere quindi sempre il risultato che cerchi. Chiavi e valori possono essere co­sti­tui­ti da tipi di dati com­ple­ta­men­te diversi, come stringhe, numeri o altri oggetti.

La classe Java HashMap offre quindi numerosi vantaggi in un colpo solo. Ti permette infatti di eseguire ricerche all’interno del lin­guag­gio di pro­gram­ma­zio­ne in modo rapido e con successo. Al tempo stesso, l’approccio chiave-valore impedisce l’as­se­gna­zio­ne di più valori a una stessa chiave. In questo modo è esclusa la pos­si­bi­li­tà di duplicati. Solo gli oggetti possono essere aggiunti anche più volte con chiavi diverse. Questo tipo di me­mo­riz­za­zio­ne e ricerca ha effetti positivi anche sulle pre­sta­zio­ni rispetto alle liste bloccate, che sono di gran lunga meno fles­si­bi­li. Questo è anche uno dei prin­ci­pa­li vantaggi dei Key Value Store, o database chiave-valore, che sfruttano lo stesso principio. Nelle parti seguenti ti mostriamo quindi come creare le HashMap in Java e come usarle per i tuoi scopi.

Come si creano?

Per creare una nuova HashMap in Java devi in­nan­zi­tut­to importare la classe. A tal fine, utilizza il comando Java import. Suc­ces­si­va­men­te puoi creare la mappa. Il comando si presenta così:

import java.util.HashMap;
HashMap<String, String> nomeHashMap = new HashMap<String, String> ();

I due tipi di dati separati da una virgola (in questo caso String, String) sono la chiave e il valore.

Creazione di una nuova HashMap in Java

Per chiarire meglio il fun­zio­na­men­to di questa classe, ri­cor­ria­mo a un esempio pratico. Nell’esempio dobbiamo me­mo­riz­za­re una lista di clienti che un’impresa può ri­chia­ma­re in qualsiasi momento. La lista contiene da un lato il nome del cliente e dall’altro un codice cliente. Mentre il codice cliente (nel nostro esempio, la chiave) è sempre univoco, in teoria più clienti possono avere lo stesso nome. A ciascuno di loro verrebbe comunque assegnato un proprio codice. Questo codice viene me­mo­riz­za­to come tipo di dati integer, mentre i nomi sono stringhe. La relativa HashMap in Java si presenta quindi così:

import java.util.HashMap;
public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclienti = new HashMap<>();
	}
}

Aggiunta di elementi

A questo punto abbiamo creato la HashMap in Java, che però è ancora vuota. Per ag­giun­ge­re delle nuove coppie chiave-valore uti­liz­zia­mo il metodo put(). Nel nostro esempio, la procedura è la seguente:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclienti = new HashMap<>();
	listaclienti.put (1077, "Sabine Schulz");
	listaclienti.put (15312, "Peter Smith");
	listaclienti.put (73329, "Maria Grosso");
	System.out.println(listaclienti);
	}
}

Uti­liz­zia­mo il comando System.out.println per ri­chie­de­re la vi­sua­liz­za­zio­ne della nostra lista clienti. Il risultato dovrebbe essere il seguente:

{1077=Sabine Schulz, 15312=Peter Smith, 73329=Maria Grosso}

Accesso agli elementi

A questo punto abbiamo creato una lista clienti, che in teoria può contenere molte più voci, ma vogliamo anche poter accedere ai singoli clienti. Per farlo, as­se­gnia­mo la chiave al metodo get(). Otteniamo un risultato di questo tipo:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclienti = new HashMap<>();
	listaclienti.put (1077, "Sabine Schulz");
	listaclienti.put (15312, "Peter Smith");
	listaclienti.put (73329, "Maria Grosso");
	System.out.println(listaclienti.get(1077));
	}
}

Nel nostro output dovrebbe comparire quindi soltanto il nome “Sabine Schulz”.

Rimozione di singole voci o di tutte le voci

Per rimuovere una voce specifica, utilizza il metodo remove(). Il codice da usare si presenta così:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclienti = new HashMap<>();
	listaclienti.put (1077, "Sabine Schulz");
	listaclienti.put (15312, "Peter Smith");
	listaclienti.put (73329, "Maria Grosso");
	listaclienti.remove(1077);
	System.out.println(listaclienti);
	}
}

Il risultato è quindi il seguente:

{15312=Peter Smith, 73329=Maria Grosso}

In al­ter­na­ti­va, puoi eliminare l’intera lista. A tal fine utilizza il metodo clear(). L’ap­pli­ca­zio­ne nel nostro esempio è la seguente:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclienti = new HashMap<>();
	listaclienti.put (1077, "Sabine Schulz");
	listaclienti.put (15312, "Peter Smith");
	listaclienti.put (73329, "Maria Grosso");
	listaclienti.clear();
	System.out.println(listaclienti);
	}
}

Come output otteniamo sem­pli­ce­men­te questo risultato:

{ }

Ri­le­va­men­to del numero di voci

Per la Java HashMap che abbiamo creato è facile avere una visione d’insieme, ma ov­via­men­te è possibile rea­liz­za­re anche progetti net­ta­men­te più complessi uti­liz­zan­do questa classe. Nel nostro esempio può essere molto in­te­res­san­te rilevare il numero esatto di voci diverse: in pratica, il totale della tua ana­gra­fi­ca clienti. Il metodo giusto per farlo è size(). Il suo utilizzo è il seguente:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclienti = new HashMap<>();
	listaclienti.put (1077, "Sabine Schulz");
	listaclienti.put (15312, "Peter Smith");
	listaclienti.put (73329, "Maria Grosso");
	System.out.println(listaclienti.size());
	}
}

Nel nostro esempio, fa­cil­men­te com­pren­si­bi­le, otteniamo come risultato il numero 3.

Raf­fi­gu­ra­zio­ne isolata di chiavi o valori

È anche possibile ottenere un elenco con­te­nen­te soltanto le chiavi o i valori. La base è un ciclo for-each. Per le chiavi uti­liz­zia­mo il metodo keySet(), per i valori il metodo values(). Nel nostro esempio, quest’ultimo caso si presenta così:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclienti = new HashMap<>();
	listaclienti.put (1077, "Sabine Schulz");
	listaclienti.put (15312, "Peter Smith");
	listaclienti.put (73329, "Maria Grosso");
	for (String i : listaclienti.values()) {
		System.out.println(i);
		}
	}
}

L’output è quindi il seguente:

Sabine Schulz
Peter Smith
Maria Grosso

Verifica della di­spo­ni­bi­li­tà di un elemento

È possibile non soltanto accedere a una data voce, ma anche ve­ri­fi­ca­re se un elemento è presente o meno nella Java HashMap. A tal fine uti­liz­zia­mo i metodi con­tain­sKey() (per le chiavi) e con­tain­sVa­lue() (per i valori). Se l’elemento è presente, otteniamo l’output “true”. Se l’elemento non era me­mo­riz­za­to, il risultato è “false”. Nella pratica, i due metodi fun­zio­na­no così:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclienti = new HashMap<>();
	listaclienti.put (1077, "Sabine Schulz");
	listaclienti.put (15312, "Peter Smith");
	listaclienti.put (73329, "Maria Grosso");
	System.out.println(listaclienti.containsKey(15312));
	System.out.println(listaclienti.containsValue("Stuart Miller");
	}
}

Poiché è presente la chiave “15312”, ma la lista non contiene la voce “Stuart Miller”, il risultato è il seguente:

true
false