Einführung in die HashMap-Sammlung

1. Eine Reihe von Schlüssel-Wert-Paaren.

In Java ist eine weitere interessante Sammlung (im Großen und Ganzen) Map. Manchmal wird diese Datenstruktur auch als Wörterbuch bezeichnet.

Es ähnelt der SetSammlung, speichert jedoch einen Satz von „Paaren“ von Elementen und nicht einen Satz von Elementen. Jedes Paar in a Mapbesteht aus zwei Elementen: einem „Schlüssel“ und einem „Wert“.

Nehmen wir an, Sie möchten, dass Ihr Programm die Namen der Mitarbeiter und deren Gehälter oder die Namen Ihrer Kollegen und deren Alter speichert. Dann bräuchten Sie eine Tabelle wie diese:

Jede Zeile enthält einige Werte. Wir bezeichnen den Namen als Schlüssel des Paares und das Alter als Wert des Paares .

Die gesamte Menge dieser Paare ist unsere Karte ( Map).

Der Schlüssel eines Paares kann alles außer sein null. Schlüssel müssen eindeutig sein: Eine Karte darf nicht zwei identische Schlüssel enthalten.

2. HashMapKlasse

Die HashMapKlasse ist die beliebteste Art der MapSammlung. Einerseits ist es HashSet sehr ähnlich und verfügt über alle seine Methoden. Andererseits ist es wie eine Liste ( ArrayList), die Wörter (oder alles andere) als Indizes verwenden kann.

Sie können HashMapeine Anweisung wie diese erstellen:

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

Dabei KeyTypeist der Typ der Schlüssel in den gespeicherten Paaren und ValueTypeder Typ der Werte in den in der HashMapSammlung gespeicherten Paaren.

Die HashMapKlasse verfügt über Methoden wie diese:

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

Elemente zu a hinzufügenHashMap

Mit dieser Methode werden Elemente als Paare zu einer Karte hinzugefügt put(). Als erstes Argument wird der Schlüssel und als zweites der Wert übergeben.

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

Wenn beim Hinzufügen eines Schlüssel-Wert-Paares der Schlüssel bereits in der Sammlung vorhanden ist, wird der alte Wert durch den neuen Wert ersetzt.

Dieses Verhalten ähnelt HashMapeinem Array oder einer Liste, deren Indizes Wörter ( String) anstelle von Zahlen sind.

3. Teilmengen von a HashMap: die Menge der Schlüssel

Nehmen wir an, wir möchten einfach alle Einträge in einem auf dem Bildschirm anzeigen HashMap. Wie machen wir das? Dazu müssen wir wissen, wie wir alle Einträge im . durchgehen HashMap. Dies kann auf verschiedene Arten erfolgen.

Am einfachsten ist es, die Tasten durchzuschleifen

HashMapEinträge werden nicht fortlaufend nummeriert, daher funktioniert eine Schleife mit einem Zähler hier nicht. Aber wir können mit der Methode eine Reihe von Schlüsseln erhalten keySet(), und Sie wissen bereits, wie man über eine Menge iteriert:

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

Die keySet()Methode gibt einen Satz Schlüssel zurück. Sie können dieses Set auf zwei Arten verwenden:

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. Durchlaufen von Schlüssel-Wert-Paaren

Es gibt auch einen komplizierteren Weg: Sie können a Mapin eine Menge von Schlüssel-Wert-Paaren umwandeln und dann die Elemente der Menge durchlaufen, wie wir bereits gelernt haben.

Die HashMapSammlung verfügt über eine Hilfsklasse, die ein Schlüssel-Wert-Paar speichert. Es sieht ungefähr so ​​aus:

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

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

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

Das Ergebnis des Aufrufs der entrySet()Methode für ein Objekt ist :HashMap<KeyType, ValueType>Set<Entry<KeyType, ValueType>>

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

Hier haben wir die generische SetKlasse mit einem Typparameter, die wiederum ein generischer Typ ( Entry) mit zwei Typparametern ist.

Als Anfänger kommt man hier sehr leicht in Verwirrung. Aber sobald Sie es herausgefunden haben, können Sie Code schreiben wie:

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

Allerdings kann dieser Code ein wenig vereinfacht werden:

Erstens können Sie das Erstellen einer separaten Variablen für überspringen und stattdessen die Methode direkt in der Schleife entriesaufrufen :entrySet()for

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

Zweitens können Sie den kürzlich eingeführten varOperator verwenden, um automatisch auf den Typ des Schlüssel-Wert-Paares zu schließen :

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

Nicht schlecht, oder?

5. Vergleich von ArrayListundHashMap

A HashMapähnelt stark einem ArrayList, das die Verwendung von Zeichenfolgen (oder anderen Typen) als Indizes (Schlüssel) ermöglicht.

IntegerWenn Sie for die Tasten in a verwenden HashMap, wird es einem noch ähnlicher ArrayList. Lass uns vergleichen:

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