Java HashMap: la memorizzazione di dati in coppie chiave-valore

Con la classe Java HashMap puoi memorizzare i dati in coppie chiave-valore. Questa funzionalità ti permette non soltanto di richiamare e gestire più facilmente una lista, ma ti offre anche numerose possibilità di accesso. Nelle parti seguenti ti presentiamo i principali metodi per farlo.

Che cosa sono le HashMap in Java?

Esistono diversi metodi per memorizzare e richiamare i dati. A seconda dell’applicazione, può essere più adatto un tipo di memorizzazione 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 esattamente un valore (Value). Quando desideri richiamare questo valore, puoi utilizzare la relativa chiave e ottenere quindi sempre il risultato che cerchi. Chiavi e valori possono essere costituiti da tipi di dati completamente 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 linguaggio di programmazione in modo rapido e con successo. Al tempo stesso, l’approccio chiave-valore impedisce l’assegnazione di più valori a una stessa chiave. In questo modo è esclusa la possibilità di duplicati. Solo gli oggetti possono essere aggiunti anche più volte con chiavi diverse. Questo tipo di memorizzazione e ricerca ha effetti positivi anche sulle prestazioni rispetto alle liste bloccate, che sono di gran lunga meno flessibili. Questo è anche uno dei principali 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 innanzitutto importare la classe. A tal fine, utilizza il comando Java import. Successivamente 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 funzionamento di questa classe, ricorriamo a un esempio pratico. Nell’esempio dobbiamo memorizzare una lista di clienti che un’impresa può richiamare 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 memorizzato 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 aggiungere delle nuove coppie chiave-valore utilizziamo 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);
	}
}

Utilizziamo il comando System.out.println per richiedere la visualizzazione 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, assegniamo 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 alternativa, puoi eliminare l’intera lista. A tal fine utilizza il metodo clear(). L’applicazione 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 semplicemente questo risultato:

{ }

Rilevamento del numero di voci

Per la Java HashMap che abbiamo creato è facile avere una visione d’insieme, ma ovviamente è possibile realizzare anche progetti nettamente più complessi utilizzando questa classe. Nel nostro esempio può essere molto interessante rilevare il numero esatto di voci diverse: in pratica, il totale della tua anagrafica 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, facilmente comprensibile, otteniamo come risultato il numero 3.

Raffigurazione isolata di chiavi o valori

È anche possibile ottenere un elenco contenente soltanto le chiavi o i valori. La base è un ciclo for-each. Per le chiavi utilizziamo 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 disponibilità di un elemento

È possibile non soltanto accedere a una data voce, ma anche verificare se un elemento è presente o meno nella Java HashMap. A tal fine utilizziamo i metodi containsKey() (per le chiavi) e containsValue() (per i valori). Se l’elemento è presente, otteniamo l’output “true”. Se l’elemento non era memorizzato, il risultato è “false”. Nella pratica, i due metodi funzionano 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