Introductie van de HashMap-collectie

1. Een set sleutel-waardeparen.

In Java is een andere interessante verzameling (in grote lijnen) Map. Soms wordt deze gegevensstructuur ook wel een woordenboek genoemd.

Het is vergelijkbaar met de Setverzameling, maar het slaat een reeks "paren" elementen op in plaats van een reeks elementen. Elk paar in een Mapbestaat uit twee elementen: een "sleutel" en een "waarde".

Stel dat u wilt dat uw programma de namen van werknemers en hun salarissen opslaat, of de namen van uw collega's en hun leeftijden. Dan heb je een tabel als deze nodig:

Elke rij bevat een aantal waarden. We zullen naar de naam verwijzen als de sleutel van het paar en naar de leeftijd als de waarde van het paar .

De hele set van deze paren is onze kaart ( Map).

De sleutel van een paar kan van alles zijn behalve null. Sleutels moeten uniek zijn: één map kan niet twee identieke sleutels bevatten.

2. HashMapklasse

De HashMapklasse is de meest populaire vorm van Mapverzameling. Aan de ene kant lijkt het erg op HashSet en heeft het al zijn methoden. Aan de andere kant is het als een lijst ( ArrayList) die woorden (of iets anders) als index kan gebruiken.

U kunt HashMapeen statement als volgt maken:

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

Waar KeyTypeis het type van de sleutels in de opgeslagen paren, en ValueTypeis het type van de waarden in de paren die in de HashMapverzameling zijn opgeslagen.

De HashMapklasse heeft methoden zoals deze:

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

Elementen toevoegen aan eenHashMap

Elementen worden met behulp van de methode als paren aan een kaart toegevoegd put(). De sleutel wordt doorgegeven als het eerste argument en de waarde wordt doorgegeven als het tweede.

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

Als bij het toevoegen van een sleutel-waardepaar de sleutel al in de verzameling bestaat, wordt de oude waarde vervangen door de nieuwe waarde.

Dit gedrag zorgt ervoor dat HashMapeen array of een lijst lijkt op een lijst waarvan de indexen woorden ( String) zijn in plaats van getallen.

3. Subsets van a HashMap: de set sleutels

Laten we zeggen dat we gewoon alle items in a HashMapop het scherm willen weergeven. Hoe doen we dit? Om dit te doen, moeten we weten hoe we alle vermeldingen in het HashMap. Dit kan op verschillende manieren worden gedaan.

De eenvoudigste manier is om de toetsen door te lussen

HashMapingangen zijn niet opeenvolgend genummerd, dus een lus met een teller werkt hier niet. Maar we kunnen een set sleutels krijgen met behulp van de keySet()methode, en je weet al hoe je een set moet herhalen:

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

De keySet()methode retourneert een set sleutels. Je kunt deze set op twee manieren gebruiken:

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. Looping over sleutel-waardeparen

Er is ook een meer gecompliceerde manier: je kunt a transformeren Mapin een set sleutel-waardeparen en vervolgens de elementen van de set doorlopen, zoals we al hebben geleerd.

De HashMapcollectie heeft een helperklasse die een sleutel-waardepaar opslaat. Het ziet er ongeveer zo uit:

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

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

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

Het resultaat van het aanroepen van de entrySet()methode op een object is een :HashMap<KeyType, ValueType>Set<Entry<KeyType, ValueType>>

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

Hier hebben we de generieke Setklasse met een typeparameter, die op zijn beurt een generiek type ( Entry) is met twee typeparameters.

Het is heel gemakkelijk voor een beginner om hierover in de war te raken. Maar als je het eenmaal doorhebt, kun je code schrijven zoals:

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

Dat gezegd hebbende, deze code kan een beetje worden vereenvoudigd:

Ten eerste kun je het maken van een aparte variabele voor overslaan en in plaats daarvan de methode rechtstreeks binnen de lus entriesaanroepen :entrySet()for

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

Ten tweede kunt u de onlangs geïntroduceerde varoperator gebruiken om automatisch het type sleutel-waardepaar af te leiden :

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

Niet slecht, hè?

5. Vergelijking van ArrayListenHashMap

A HashMaplijkt sterk op een ArrayListwaarmee strings (of andere typen) kunnen worden gebruikt als indexen (de sleutels).

IntegerAls je voor de sleutels in een gebruikt HashMap, dan wordt het nog meer vergelijkbaar met een ArrayList. Laten we vergelijken:

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