CodeGym /Java Course /Module 1 /Introductie van de HashMap-collectie

Introductie van de HashMap-collectie

Module 1
Niveau 18 , Les 0
Beschikbaar

1. Een set sleutel-waardeparen.

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:

Naam Leeftijd
Elon 21
Jef 22
Rekening 48
Warren ?

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:

Methode Beschrijving
void put(KeyType key, ValueType value)
Voegt het ( key, value) paar toe aan de collectie
ValueType get(KeyType key)
Retourneert de waarde die aan een sleutel is gekoppeld.
boolean containsKey(KeyType key)
Controleert of er een sleutel in de verzameling bestaat
boolean containsValue(ValueType value)
Controleert op het bestaan ​​van een waarde in de verzameling
ValueType remove(KeyType key)
Verwijdert een element uit de verzameling
void clear()
Wist de verzameling en verwijdert alle elementen
int size()
Retourneert het aantal sleutel-waardeparen in de verzameling
Set<KeyType> keySet()
Retourneert de set sleutels in de verzameling
Collection<ValueType> values()
Retourneert een set die de elementen van de verzameling bevat
Set<Map.Entry<KeyType, ValueType>> entrySet()
Retourneert een set ( Set) van alle paren ( Map.Entry) in de verzameling.

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.

Belangrijk:

Bijna elk type kan het KeyType of ValueType zijn. Er zijn enkele kleine aanvullende vereisten voor het KeyType, en u zult hierover meer te weten komen wanneer u collecties in meer detail bestudeert in de Java Collections-zoektocht.



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:

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






Loop over de sleutels van de map

Verkrijg de waarde die aan de sleutel is gekoppeld

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

Compacte notatie Lange notatie
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:

Codeer met ArrayList<String> Codeer met HashMap<Integer, String>
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);
}

Opmerkingen
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION