Veeg om het menu te tonen

We bespreken de Map-interface in Java. De Map-interface maakt deel uit van het Java Collections framework en definieert methoden voor het werken met gegevens in de vorm van sleutel-waardeparen.

Laten we de definitie bekijken:

De primaire implementatie van een dergelijke datastructuur in Java is HashMap, die de Map-interface implementeert. Laten we de belangrijkste methoden en de werkingsprincipes van deze implementatie verkennen.

We beginnen met de declaratie en methoden:

Main.java


              1
            
Map<K, V> map = new HashMap<>();

Hier zie je dat in de generics of diamant-haakjes twee waarden worden gespecificeerd:

De waarde K komt overeen met het gegevenstype van de sleutel;
De waarde V komt overeen met het gegevenstype van de waarde.

Dus, bij het declareren van deze datastructuur geven we de gegevenstypen van onze sleutel-waarde-paren aan.

Laten we nu de methoden gedefinieerd in de Map interface bekijken.

Methoden

V put(K key, V value): koppelt de gespecificeerde waarde aan de gespecificeerde sleutel in deze Map. Als de Map eerder al een koppeling voor de sleutel bevatte, wordt de oude waarde vervangen.

Main.java


              1234567891011121314
            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println(map);
    }
}

V get(Object key): geeft de waarde terug waaraan de opgegeven sleutel is gekoppeld, of null als deze Map geen koppeling voor de sleutel bevat.

Hier specificeer je de sleutel om de bijbehorende waarde op te halen.

De waarde met sleutel 2 ophalen:

Main.java


              12345678910111213141516
            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String value = map.get(2);
        System.out.println("Value: " + value);
    }
}

boolean containsKey(Object key): geeft true terug als de Map een koppeling bevat voor de opgegeven sleutel;
boolean containsValue(Object value): geeft true terug als de Map een of meer sleutels bevat die zijn gekoppeld aan de opgegeven waarde.

Deze twee methoden zijn duidelijk verwant en helpen bepalen of de opgegeven Map de gewenste sleutels of waarden bevat. Deze methoden zijn handig om als voorwaarden te gebruiken omdat ze boolean waarden retourneren.

Een voorbeeld:

Main.java


              12345678910111213141516171819202122232425
            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        if (map.containsKey(2)) {
            System.out.println("Value with key 2: " + map.get(2));
        } else {
            System.out.println("There is no value with key 2!");
        }

        if (map.containsValue("Four")) {
            System.out.println(map.get(4));
        } else {
            System.out.println("There is no key with value \"Four\"!");
        }
    }
}

In het bovenstaande voorbeeld controleren we op de aanwezigheid van een sleutel en de aanwezigheid van een waarde in de Map. Indien waarden worden gevonden, worden deze weergegeven op de console. Als er geen dergelijke waarden zijn, worden berichten weergegeven die de afwezigheid van dergelijke gegevens aangeven.

boolean isEmpty(): retourneert true als deze Map geen sleutel-waardeparen bevat;
V remove(Object key): verwijdert de koppeling voor de gespecificeerde sleutel uit deze Map indien aanwezig en retourneert de vorige waarde.

Net als bij andere datastructuren kun je elementen verwijderen uit de Map.

Main.java


              12345678910111213141516
            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String removedElement = map.remove(3);
        System.out.println("Removed value: " + removedElement + ".\nMap after the removal operation: " + map);
    }
}

Zo kunnen we elementen op sleutel verwijderen.

Basis methoden voor het beheren van Maps

Vervolgens zijn er methoden waarmee je al bekend bent, die ik zonder voorbeelden zal opsommen. Maar er zijn ook interessante methoden overgebleven.

Laten we beginnen met de basis:

void clear(): verwijdert alle elementen uit de Map;
int size(): geeft het aantal sleutel-waarde koppelingen in deze Map terug;
void putAll(Map<? extends K, ? extends V> m): kopieert alle koppelingen van de opgegeven Map naar deze Map.

Nu gaan we verder met de methoden die een collectie retourneren met waarden (of sleutels) uit de Map. Met andere woorden, we halen uit de datastructuur een sleutel-waarde structuur die alleen waarden (of sleutels) opslaat. Bijvoorbeeld, ArrayList<>.

Main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> list;
        list = map.values();
        System.out.println("Values" + list);
    }
}

Hier hebben we een collectie van waarden verkregen uit de Map. Nu kunnen we deze collectie overdragen naar een ArrayList:

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> collection;
        collection = map.values();
        System.out.println("Values" + collection);
        List<String> arrayList = new ArrayList<>(collection);
        System.out.println("ArrayList: " + arrayList);
    }
}

We hebben een ArrayList geïnitialiseerd met waarden uit de Map.

Er is ook een methode die sleutels retourneert uit de Map. Deze sleutels worden echter teruggegeven in de vorm van een structuur genaamd een Set. We gaan nu niet dieper in op deze datastructuur; het is belangrijk om te vermelden dat een Set een datastructuur is die uitsluitend unieke waarden bevat.

Bekijk deze methode:

Set<K> keySet(): retourneert een Set-weergave van de sleutels die in deze Map aanwezig zijn.

Main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Set<Integer> keys;
        keys = map.keySet();
        System.out.println("Keys: " + keys);
    }
}

Zo kunnen we ook een set van alle sleutels uit de Map ophalen.

Het lijkt erop dat we klaar zijn met de methoden. Laten we nu kijken naar het gebruik van de Map, evenals praktische voorbeelden:

Gebruik van Map

Een structuur zoals key-value heeft veel praktische toepassingen. Laten we de eenvoudigste van deze structuren bekijken: een studentenbeoordelingssysteem.

Laten we een Map maken waarbij de sleutel van het type String is, wat de naam van de student voorstelt, en de waarde van het type Integer, wat het cijfer van de student voorstelt. Op deze manier kun je cijfers aan studenten toewijzen en eenvoudig het cijfer van een specifieke student ophalen met behulp van de sleutel:

Main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
    }
}

Stel je nu voor dat we de cijfers van Mike en Alice moeten ophalen en vervolgens vergelijken. Dit kan eenvoudig worden uitgevoerd met de methoden die hierboven zijn besproken. Hieronder volgt de implementatie in de code:

Main.java


              123456789101112131415161718192021
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        System.out.println(mikeGrade.compareTo(aliceGrade) == -1 ? "Alice's grade is higher": "Mike's grade is higher");
    }
}

De ternaire operator en de methode compareTo() van de Integer wrapperklasse zijn gebruikt. Mocht het niet duidelijk zijn hoe dit werkt, dan volgt hier een uitleg:

Main.java


              12345678910111213141516171819202122232425
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        if (mikeGrade.compareTo(aliceGrade) == -1) {
            System.out.println("Alice's grade is higher");
        } else {
            System.out.println("Mike's grade is higher");
        }
    }
}

Laten we nu eens bekijken wat er gebeurt als we alle studenten met een cijfer hoger dan 7 (exclusief 7) moeten verzamelen. Dit wordt interessant, en ik zal nu uitleggen hoe je dit kunt doen!

Iteratie door de Map

Itereren over elementen in een Map in Java kan op verschillende manieren met behulp van de methoden die door de Map-interface en de implementaties ervan worden aangeboden. Hier volgen enkele manieren om door een Map te itereren:

Itereren over sleutels (keySet()): de methode keySet() retourneert een set van alle sleutels in de Map. Je kunt deze set gebruiken om over de sleutels te itereren en de bijbehorende waarden op te halen.

Main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (String key : map.keySet()) {
            Integer value = map.get(key);
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

Itereren over waarden (values()): de methode values() retourneert een collectie van alle waarden in de Map. Deze collectie kan worden gebruikt om over de waarden te itereren.

Main.java


              123456789101112131415
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Integer value : map.values()) {
            System.out.println("Value: " + value);
        }
    }
}

Itereren over sleutel-waardeparen (entrySet()): de methode entrySet() retourneert een set van Map.Entry-objecten die sleutel-waardeparen vertegenwoordigen. Dit maakt het mogelijk om direct over paren te itereren.

Main.java


              1234567891011121314151617
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

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

Laten we hier wat dieper op ingaan. In eerste instantie lijkt het buitengewoon complex om te begrijpen, maar het is niet nodig om in detail te weten hoe het werkt, aangezien de syntaxis altijd hetzelfde is.

Map.Entry<K, V> entry : map.entrySet()

Met het entry-object kun je gelijktijdig zowel de sleutel als de waarde in de Map benaderen. Nu gaan we de eerder gegeven opdracht oplossen met behulp van de entry set: alle studenten ophalen met een cijfer hoger dan 7. Hiervoor gebruiken we een controle via entry.getValue(), en wanneer we geschikte studenten vinden, halen we hun sleutels op in een vooraf aangemaakte ArrayList:

Main.java


              1234567891011121314151617181920212223242526
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
        
        List<String> studentsWithGradeHigherThanSeven = new ArrayList<>();
        
        for (Map.Entry<String, Integer> entry : studentsGrades.entrySet()) {
            if (entry.getValue() > 7) {
                studentsWithGradeHigherThanSeven.add(entry.getKey());
            }
        
        }
        System.out.println(studentsWithGradeHigherThanSeven);
    }
}

Zo kun je door de Map itereren en de gewenste lijst van studenten vinden die geslaagd zijn voor het examen!

De entry set is een zeer nuttig hulpmiddel omdat het verschillende manieren biedt om door de Map te itereren met een lus, waarbij toegang is tot zowel de sleutel als de waarde.

In het volgende hoofdstuk gaan we dieper in op hoe HashMap, die we in dit hoofdstuk zo actief hebben gebruikt, daadwerkelijk werkt!

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 1. Hoofdstuk 13

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Sectie 1. Hoofdstuk 13

Wat Is Een Map?

Methoden

Basis methoden voor het beheren van Maps

Gebruik van Map

Iteratie door de Map

1. Welke interface in Java vertegenwoordigt een verzameling van sleutel-waardeparen?

2. Hoe doorloop je alle sleutels in een `Map` met een for-each-lus?

3. Wat is het doel van de methode `values()` in een `Map`?

4. Welke methode wordt gebruikt om te controleren of een specifieke sleutel aanwezig is in een `Map`?

5. Welke methode wordt gebruikt om een sleutel-waarde paar uit een `Map` in Java te verwijderen?

Wat Is Een Map?

Methoden

Basis methoden voor het beheren van Maps

Gebruik van Map

Iteratie door de Map

1. Welke interface in Java vertegenwoordigt een verzameling van sleutel-waardeparen?

2. Hoe doorloop je alle sleutels in een Map met een for-each-lus?

3. Wat is het doel van de methode values() in een Map?

4. Welke methode wordt gebruikt om te controleren of een specifieke sleutel aanwezig is in een Map?

5. Welke methode wordt gebruikt om een sleutel-waarde paar uit een Map in Java te verwijderen?

2. Hoe doorloop je alle sleutels in een `Map` met een for-each-lus?

3. Wat is het doel van de methode `values()` in een `Map`?

4. Welke methode wordt gebruikt om te controleren of een specifieke sleutel aanwezig is in een `Map`?

5. Welke methode wordt gebruikt om een sleutel-waarde paar uit een `Map` in Java te verwijderen?