Introduzione alla raccolta HashMap

1. Un insieme di coppie chiave-valore.

In Java, un'altra raccolta interessante (in senso lato) è Map. A volte questa struttura dati è anche chiamata dizionario.

È simile alla Setraccolta, ma memorizza un insieme di "coppie" di elementi piuttosto che un insieme di elementi. Ciascuna coppia in a Mapconsiste di due elementi: una "chiave" e un "valore".

Supponiamo che tu voglia che il tuo programma memorizzi i nomi dei dipendenti e i loro stipendi, o i nomi dei tuoi colleghi e la loro età. Quindi avresti bisogno di una tabella come questa:

Ogni riga contiene un paio di valori. Faremo riferimento al nome come chiave della coppia e all'età come valore della coppia .

L'intero insieme di queste coppie è la nostra mappa ( Map).

La chiave di una coppia può essere qualsiasi cosa tranne null. Le chiavi devono essere univoche: una mappa non può contenere due chiavi identiche.

2. HashMapclasse

La HashMapclasse è il tipo di Mapraccolta più popolare. Da un lato, è molto simile a HashSet e ha tutti i suoi metodi. D'altra parte, è come una lista ( ArrayList) che può usare parole (o qualsiasi altra cosa) come indici.

È possibile creare un HashMaputilizzando una dichiarazione come questa:

HashMap<KeyType, ValueType> name = new HashMap<KeyType, ValueType>();

Dove KeyTypeè il tipo delle chiavi nelle coppie archiviate ed ValueTypeè il tipo dei valori nelle coppie archiviate nella HashMapraccolta.

La HashMapclasse ha metodi come questo:

void put(KeyType key, ValueType value)

ValueType get(KeyType key)

boolean containsKey(KeyType key)

boolean containsValue(ValueType value)

ValueType remove(KeyType key)

void clear()

int size()

Set<KeyType> keySet()

Collection<ValueType> values()

Set<Map.Entry<KeyType, ValueType>> entrySet()

Aggiunta di elementi aHashMap

Gli elementi vengono aggiunti a una mappa come coppie utilizzando il put()metodo. La chiave viene passata come primo argomento e il valore viene passato come secondo.

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

Quando si aggiunge una coppia chiave-valore, se la chiave esiste già nella raccolta, il vecchio valore viene sostituito dal nuovo valore.

Questo comportamento rende HashMapsimile un array o un elenco i cui indici sono parole ( String) anziché numeri.

3. Sottoinsiemi di a HashMap: il set di chiavi

Diciamo che vogliamo solo visualizzare tutte le voci in a HashMapsullo schermo. Come facciamo questo? Per fare ciò, dobbiamo sapere come esaminare tutte le voci nel file HashMap. Questo può essere fatto in diversi modi.

Il modo più semplice è passare in rassegna i tasti

HashMaple voci non sono numerate in sequenza, quindi un ciclo con un contatore non funzionerà qui. Ma possiamo ottenere un set di chiavi usando il keySet()metodo e sai già come iterare su un set:

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

for (String key: map.keySet())
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

Il keySet()metodo restituisce un set di chiavi. Puoi utilizzare questo set in due modi:

for (String key: map.keySet())
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

Set<String> keys = map.keySet();

for (String key: keys)
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

4. Loop su coppie chiave-valore

C'è anche un modo più complicato: puoi trasformare a Mapin un insieme di coppie chiave-valore e poi scorrere gli elementi dell'insieme, come abbiamo già imparato.

La HashMapraccolta ha una classe helper che archivia una coppia chiave-valore. Sembra approssimativamente così:

class Entry<KeyType, ValueType>
{
   private KeyType key;
   private ValueType value;

   public KeyType getKey()
   {
      return this.key;
   }

   public ValueType getValue()
   {
      return this.value;
   }
}

Il risultato della chiamata al entrySet()metodo su un oggetto sarà un :HashMap<KeyType, ValueType>Set<Entry<KeyType, ValueType>>

Set<Entry<KeyType, ValueType>> name = map.entrySet();

Qui abbiamo la Setclasse generica con un parametro di tipo, che a sua volta è un tipo generico ( Entry) con due parametri di tipo.

È molto facile per un principiante confondersi su questo. Ma una volta capito, puoi scrivere codice come:

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

Set<Map.Entry<String, Integer>> entries = map.entrySet();
for(Map.Entry<String, Integer> pair: entries)
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

Detto questo, questo codice può essere un po' semplificato:

Innanzitutto, puoi saltare la creazione di una variabile separata per entriese invece chiamare il entrySet()metodo direttamente all'interno del forciclo:

for(Map.Entry<String, Integer> pair: map.entrySet())
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

In secondo luogo, è possibile utilizzare l' varoperatore introdotto di recente per dedurre automaticamente il tipo della coppia chiave-valore :

for(var pair: map.entrySet())
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

Non male, eh?

5. Confronto di ArrayListeHashMap

A HashMapsomiglia molto a an ArrayListche consente di utilizzare stringhe (o altri tipi) come indici (le chiavi).

Se usi Integerper le chiavi in ​​a HashMap, diventa ancora più simile a un ArrayList. Confrontiamo:

ArrayList<String> list = new ArrayList<String>();

list.add("Greetings");
list.add("Hello");

String s = list.get(0);
list.set(0, s + "!");

for (String item: list)
{
   System.out.println(item);
}

HashMap<Integer, String> map = new HashMap<Integer, String>();

map.put(0, "Greetings");
map.put(1, "Hello");

String s = map.get(0);
map.put(0, s + "!");

for (String item: map.values())
{
   System.out.println(item);
}