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.

Hier volgt de definitie:

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

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): retourneert true als de Map een koppeling bevat voor de opgegeven sleutel;
boolean containsValue(Object value): retourneert true 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.

Bekijk het volgende 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 wordt gecontroleerd 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. Indien er geen dergelijke waarden zijn, worden berichten weergegeven die de afwezigheid van dergelijke gegevens aangeven.

boolean isEmpty(): retourneert true als deze Map geen sleutel-waarde koppelingen 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 kunnen elementen worden verwijderd 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 nog interessante methoden over.

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 het vermelden waard 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.

We lijken nu klaar te 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 cijferregistratiesysteem voor studenten.

We maken een Map waarbij de sleutel van het type String is, wat de naam van de student voorstelt, en de waarde van het type Integer is, wat het cijfer van de student voorstelt. Op deze manier kun je cijfers aan studenten toewijzen en eenvoudig het cijfer van een specifieke student opzoeken 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 voor dat we de opdracht krijgen om de cijfers van Mike en Alice op te halen en deze vervolgens te vergelijken. Dit kun je eenvoudig doen met de methoden die je hierboven hebt geleerd. Laten we dit in de code implementeren:

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 je niet begrijpen hoe dit werkt, dan kan het als volgt worden uitgelegd:

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 wordt gevraagd om alle studenten met een cijfer hoger dan 7 (7 niet inbegrepen) te verzamelen. Dit wordt interessant, en ik zal nu uitleggen hoe dit gedaan kan worden!

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. Deze set kan worden gebruikt 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. Hiermee kan direct over de paren worden geïtereerd.

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, eigenlijk werkt!

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 3. Hoofdstuk 1

Vraag AI

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

Veeg om het menu te tonen

Hier volgt de definitie:

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

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): retourneert true als de Map een koppeling bevat voor de opgegeven sleutel;
boolean containsValue(Object value): retourneert true als de Map een of meer sleutels bevat die zijn gekoppeld aan de opgegeven waarde.

Bekijk het volgende 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\"!");
        }
    }
}

boolean isEmpty(): retourneert true als deze Map geen sleutel-waarde koppelingen 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 kunnen elementen worden verwijderd 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 nog interessante methoden over.

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.

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.

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.

We lijken nu klaar te 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 cijferregistratiesysteem voor studenten.

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

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 je niet begrijpen hoe dit werkt, dan kan het als volgt worden uitgelegd:

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

Iteratie door de Map

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

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

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

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, eigenlijk werkt!

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 3. Hoofdstuk 1

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 key-value-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 key-value-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 key-value-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 key-value-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 key-value-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 key-value-paar uit een `Map` in Java te verwijderen?