Vi introduserer HashMap-samlingen

1. Et sett med nøkkelverdi-par.

I Java er en annen interessant samling (grovt sett) Map. Noen ganger kalles denne datastrukturen også en ordbok.

Den ligner på Setsamlingen, men den lagrer et sett med "par" av elementer i stedet for et sett med elementer. Hvert par i a Mapbestår av to elementer: en "nøkkel" og en "verdi".

La oss si at du vil at programmet skal lagre ansattes navn og deres lønn, eller navnene på kollegaene dine og deres alder. Da trenger du et bord som dette:

Hver rad inneholder et par verdier. Vi vil referere til navnet som parets nøkkel , og alderen som parets verdi .

Hele settet med disse parene er kartet vårt ( Map).

Et pars nøkkel kan være alt unntatt null. Nøkler må være unike: ett kart kan ikke inneholde to identiske nøkler.

2. HashMapklasse

Klassen HashMaper den mest populære typen Mapsamling. På den ene siden ligner den veldig på HashSet og har alle sine metoder. På den annen side er det som en liste ( ArrayList) som kan bruke ord (eller noe annet) som sine indekser.

Du kan lage en HashMapved å bruke en uttalelse som denne:

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

Hvor KeyTypeer typen av nøklene i de lagrede parene, og ValueTypeer typen av verdiene i parene som er lagret i HashMapsamlingen.

Klassen HashMaphar metoder som dette:

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()

Legge til elementer i enHashMap

Elementer legges til et kart som par ved hjelp av put()metoden. Nøkkelen sendes som det første argumentet, og verdien sendes som det andre.

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

Når du legger til et nøkkel-verdi-par, hvis nøkkelen allerede finnes i samlingen, erstattes den gamle verdien med den nye verdien.

Denne oppførselen gjør en HashMaplike til en matrise eller en liste hvis indekser er ord ( String) i stedet for tall.

3. Undersett av a HashMap: settet med nøkler

La oss si at vi bare vil vise alle oppføringene i en HashMappå skjermen. Hvordan gjør vi dette? For å gjøre dette må vi vite hvordan vi skal gå gjennom alle oppføringene i HashMap. Dette kan gjøres på flere måter.

Den enkleste måten er å løkke over tastene

HashMapoppføringer er ikke nummerert sekvensielt, så en løkke med en teller vil ikke fungere her. Men vi kan få et sett med nøkler ved å bruke keySet()metoden, og du vet allerede hvordan du itererer over et sett:

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

Metoden keySet()returnerer et sett med nøkler. Du kan bruke dette settet på to måter:

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. Sløyfe over nøkkelverdi-par

Det er også en mer komplisert måte: du kan transformere a Maptil et sett med nøkkelverdi-par , og deretter løkke over elementene i settet, som vi allerede har lært.

Samlingen HashMaphar en hjelpeklasse som lagrer et nøkkelverdi-par. Det ser omtrent slik ut:

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

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

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

Resultatet av å kalle entrySet()metoden på et objekt vil være en :HashMap<KeyType, ValueType>Set<Entry<KeyType, ValueType>>

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

Her har vi den generiske Setklassen med en typeparameter, som igjen er en generisk type ( Entry) med to typeparametere.

Det er veldig lett for en nybegynner å bli forvirret over dette. Men når du finner ut av det, kan du skrive kode som:

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

Når det er sagt, kan denne koden forenkles litt:

Først kan du hoppe over å lage en egen variabel for entriesog i stedet kalle entrySet()metoden direkte inne i forloopen:

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

For det andre kan du bruke den nylig introduserte varoperatoren til automatisk å utlede typen nøkkelverdi-par :

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

Ikke verst, ikke sant?

5. Sammenligning av ArrayListogHashMap

A HashMapligner sterkt på en ArrayListsom lar strenger (eller andre typer) brukes som indekser (nøklene).

Hvis du bruker Integerfor tastene i en HashMap, så blir den enda mer lik en ArrayList. La oss sammenligne:

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