Wat is een Java HashMap en hoe gebruik je deze?

Met de HashMap-klasse in Java kunt u gegevens opslaan in sleutel-waar­de­pa­ren. Dit maakt het niet alleen ge­mak­ke­lij­ker om een lijst op te halen en te beheren, maar biedt u ook tal van toe­gangs­op­ties. We zullen hier de be­lang­rijk­ste methoden bespreken.

Wat zijn HashMaps in Java?

Er zijn ver­schil­len­de manieren om gegevens op te slaan en op te halen. Welk type opslag het beste werkt, hangt af van hoe u de gegevens wilt gebruiken. In veel gevallen is de Java HashMap-klasse waar­schijn­lijk de beste oplossing. In te­gen­stel­ling tot andere methoden slaat deze klasse gegevens op als sleutel-waar­de­pa­ren. Dit betekent dat aan elke sleutel precies één waarde wordt toe­ge­we­zen. Als u een waarde wilt ophalen, kunt u de bij­be­ho­ren­de sleutel gebruiken om het gewenste resultaat te krijgen. Sleutels en waarden kunnen bestaan uit totaal ver­schil­len­de ge­ge­vens­ty­pen, waaronder te­ken­reek­sen, getallen of andere objecten.

De Java HashMap-klasse biedt ver­schil­len­de voordelen. Het eerste voordeel is dat u snel kunt zoeken binnen de pro­gram­meer­taal. De sleutel-waar­de­be­na­de­ring zorgt er ook voor dat er niet meerdere waarden aan één sleutel worden toe­ge­we­zen, waardoor du­pli­ca­ties worden voorkomen. U kunt echter wel hetzelfde object meerdere keren toevoegen met ver­schil­len­de sleutels. Dit type opslag- en zoek­func­ti­o­na­li­teit heeft een positief effect op de pres­ta­ties in ver­ge­lij­king met rigide lijsten, die aan­zien­lijk minder flexibel zijn. Dit is ook een van de grote voordelen van sleutel-waar­de­op­slag­plaat­sen, die hetzelfde principe gebruiken. In de volgende pa­ra­gra­fen laten we u zien hoe u Java HashMaps kunt maken en gebruiken.

Hoe HashMaps in Java te maken en te gebruiken

Om een nieuwe HashMap in Java te maken, moet je eerst de klasse im­por­te­ren. Gebruik hiervoor het Java-commando import. De code ziet er als volgt uit:

import java.util.HashMap;
HashMap<String, String> nameOfTheHashMap = new HashMap<String, String> ();

De twee ge­ge­vens­ty­pen, die worden ge­schei­den door een komma (in dit geval String, String), zijn de sleutel en de waarde.

Een nieuwe HashMap maken

Om beter uit te leggen hoe Java HashMaps werken, hebben we een eenvoudig voorbeeld bedacht. Voor ons voorbeeld hebben we een lijst met klanten die een bedrijf wil opslaan en op elk moment wil kunnen raad­ple­gen. De lijst bevat de naam van elke klant en een uniek klant­num­mer. Hoewel het klant­num­mer (de sleutel in ons voorbeeld) altijd uniek is, is het mogelijk dat meerdere klanten dezelfde naam hebben. Elk van deze klanten heeft echter een eigen uniek nummer. Dit nummer wordt op­ge­sla­gen als een integer ge­ge­vens­ty­pe en de namen als strings. Hieronder wordt uitgelegd hoe u dit in een Java HashMap kunt instellen:

import java.util.HashMap;
public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	}
}

Elementen toevoegen

Nu hebben we de Java HashMap, maar deze is nog leeg. Om nieuwe sleutel-waar­de­pa­ren toe te voegen, gaan we de methode put() gebruiken. Zo werkt het:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	customerList.put (1077, "Jerry Mowry");
	customerList.put (15312, "Peter Smith");
	customerList.put (73329, "Maria Grosso");
	System.out.println(customerList);
	}
}

We gebruiken het commando System.out.println om onze klan­ten­lijst weer te geven. De uitvoer zou er als volgt uit moeten zien:

{1077=Jerry Mowry, 15312=Peter Smith, 73329=Maria Grosso}

Elementen ophalen

Nu hebben we een klan­ten­lijst opgezet die talrijke ver­mel­din­gen kan bevatten. We willen ook elke klant­ver­mel­ding af­zon­der­lijk kunnen openen. Hiervoor geven we de sleutel door aan de methode get(). Hier is een voorbeeld van hoe dit werkt:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	customerList.put (1077, "Jerry Mowry");
	customerList.put (15312, "Peter Smith");
	customerList.put (73329, "Maria Grosso");
	System.out.println(customerList.get(1077));
	}
}

Alleen de naam ‘Jerry Mowry’ mag worden weer­ge­ge­ven.

Ver­wij­de­ren van ver­mel­din­gen

Als u een ver­mel­ding wilt ver­wij­de­ren, gebruikt u de remove() methode. Hier volgt een voorbeeld van hoe u deze methode kunt gebruiken:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	customerList.put (1077, "Jerry Mowry");
	customerList.put (15312, "Peter Smith");
	customerList.put (73329, "Maria Grosso");
	customerList.remove(1077);
	System.out.println(customerList);
	}
}

De uitvoer ziet er nu als volgt uit:

{15312=Peter Smith, 73329=Maria Grosso}

Een andere optie is om de hele lijst te ver­wij­de­ren. Gebruik hiervoor de clear().

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	customerList.put (1077, "Jerry Mowry");
	customerList.put (15312, "Peter Smith");
	customerList.put (73329, "Maria Grosso");
	customerList.clear();
	System.out.println(customerList);
	}
}

Nu is de enige uitvoer die we krijgen deze:

{ }

Hoe bepaal je het aantal in­zen­din­gen?

Hoewel onze Java HashMap vrij eenvoudig is, kunt u deze klasse ook gebruiken om grotere, com­plexe­re projecten te beheren. Bij een groter project wilt u misschien het exacte aantal items bepalen dat u hebt. Dit is immers uw volledige klan­ten­be­stand. U kunt hiervoor size() gebruiken. Dat doet u als volgt:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	customerList.put (1077, "Jerry Mowry");
	customerList.put (15312, "Peter Smith");
	customerList.put (73329, "Maria Grosso");
	System.out.println(customerList.size());
	}
}

In ons voorbeeld wordt het getal 3 weer­ge­ge­ven.

Hoe alleen sleutels of waarden weergeven

U kunt ook een lijst ver­krij­gen die alleen de sleutels of de waarden bevat, met behulp van een for-each-lus. Gebruik de methode keySet() om sleutels op te halen en de methode values() voor waarden. In het volgende co­de­voor­beeld gebruiken we values():

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	customerList.put (1077, "Jerry Mowry");
	customerList.put (15312, "Peter Smith");
	customerList.put (73329, "Maria Grosso");
	for (String i : customerList.values()) {
		System.out.println(i);
		}
	}
}

De uitvoer is:

Jerry Mowry
Peter Smith
Maria Grosso

Con­tro­le­ren of een HashMap een spe­ci­fie­ke waarde of sleutel bevat

Naast het openen van een spe­ci­fie­ke invoer, kunt u ook con­tro­le­ren of een invoer al bestaat in een Java HashMap. U kunt dit doen met behulp van methode containsKey() (voor sleutels) en methode containsValue() (voor waarden). Als het element is opgenomen, is de uitvoer ‘true’. Als het element niet in de HashMap staat, is de uitvoer ‘false’. Hieronder ziet u hoe beide methoden werken:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> customerList = new HashMap<>();
	customerList.put (1077, "Jerry Mowry");
	customerList.put (15312, "Peter Smith");
	customerList.put (73329, "Maria Grosso");
	System.out.println(customerList.containsKey(15312));
	System.out.println(customerList.containsValue("Stuart Miller");
	}
}

Aangezien de sleutel ‘15312’ is opgenomen, maar de waarde ‘Stuart Miller’ niet, ziet de uitvoer er als volgt uit.

true
false