Wir besprechen das Map-Interface in Java. Das Map-Interface ist Teil des Java Collections Framework und definiert Methoden zur Arbeit mit Daten in Form von Schlüssel-Wert-Paaren.

Hier ist die Definition:

Die wichtigste Implementierung einer solchen Datenstruktur in Java ist HashMap, welche das Map-Interface implementiert. Im Folgenden werden die Hauptmethoden und die Funktionsweise dieser Implementierung erläutert.

Zunächst die Deklaration und Methoden:

Main.java


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

Hier sehen Sie, dass in den Generics oder Diamantklammern zwei Werte angegeben werden:

Der Wert K entspricht dem Datentyp des Schlüssels;
Der Wert V entspricht dem Datentyp des Werts.

Somit geben wir beim Deklarieren dieser Datenstruktur die Datentypen unserer Schlüssel-Wert-Paare an.

Nun betrachten wir die in der Map -Schnittstelle definierten Methoden.

Methoden

V put(K key, V value): Ordnet den angegebenen Wert dem angegebenen Schlüssel in dieser Map zu. Falls die Map bereits eine Zuordnung für den Schlüssel enthielt, wird der alte Wert ersetzt.

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): gibt den Wert zurück, dem der angegebene Schlüssel zugeordnet ist, oder null, wenn diese Map keine Zuordnung für den Schlüssel enthält.

Hier wird der Schlüssel angegeben, um den zugehörigen Wert abzurufen.

Abruf des Werts mit Schlüssel 2:

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): gibt true zurück, wenn die Map eine Zuordnung für den angegebenen Schlüssel enthält;
boolean containsValue(Object value): gibt true zurück, wenn die Map einen oder mehrere Schlüssel enthält, die dem angegebenen Wert zugeordnet sind.

Diese beiden Methoden sind offensichtlich verwandt und helfen festzustellen, ob die angegebene Map die gewünschten Schlüssel oder Werte enthält. Diese Methoden sind praktisch, um sie als Bedingungen zu verwenden, da sie boolean-Werte zurückgeben.

Ein Beispiel:

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

Im obigen Beispiel wird die Existenz eines Schlüssels und die Existenz eines Werts im Map überprüft. Wenn Werte gefunden werden, werden sie auf der Konsole angezeigt. Falls keine entsprechenden Werte vorhanden sind, werden Meldungen ausgegeben, die auf das Fehlen solcher Daten hinweisen.

boolean isEmpty(): Gibt true zurück, wenn dieses Map keine Schlüssel-Wert-Zuordnungen enthält;
V remove(Object key): Entfernt die Zuordnung für den angegebenen Schlüssel aus diesem Map, falls vorhanden, und gibt den vorherigen Wert zurück.

Wie bei anderen Datenstrukturen können Sie auch im Map Elemente entfernen.

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

Somit können wir Elemente nach Schlüssel entfernen.

Grundlegende Methoden zur Verwaltung von Maps

Als Nächstes gibt es Methoden, die Ihnen bereits bekannt sind, die ich ohne Beispiele auflisten werde. Es bleiben jedoch auch noch interessante Methoden übrig.

Beginnen wir mit den Grundlagen:

void clear(): entfernt alle Elemente aus der Map;
int size(): gibt die Anzahl der Schlüssel-Wert-Zuordnungen in dieser Map zurück;
void putAll(Map<? extends K, ? extends V> m): kopiert alle Zuordnungen aus der angegebenen Map in diese Map.

Nun gehen wir zu den Methoden über, die eine Sammlung mit Werten (oder Schlüsseln) aus der Map zurückgeben. Anders gesagt, wir entnehmen aus der Datenstruktur eine Schlüssel-Wert-Struktur, die nur Werte (oder Schlüssel) speichert. Zum Beispiel 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 haben wir eine Sammlung von Werten aus der Map erhalten. Nun können wir diese Sammlung in eine ArrayList übertragen:

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

Wir haben eine ArrayList mit Werten aus der Map initialisiert.

Es gibt auch eine Methode, die Schlüssel aus der Map zurückgibt. Diese Schlüssel werden jedoch in Form einer Struktur namens Set zurückgegeben. Auf diese Datenstruktur gehen wir jetzt nicht näher ein; es sei erwähnt, dass ein Set eine Datenstruktur ist, die ausschließlich eindeutige Werte enthält.

Betrachten wir diese Methode:

Set<K> keySet(): gibt eine Set-Ansicht der in dieser Map enthaltenen Schlüssel zurück.

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

Somit können wir auch eine Menge aller Schlüssel aus der Map abrufen.

Damit sind wir mit den Methoden fertig. Schauen wir uns nun die Verwendung der Map sowie praktische Beispiele an:

Verwendung von Map

Eine Struktur wie Schlüssel-Wert hat viele praktische Anwendungsfälle. Betrachten wir die einfachste dieser Strukturen: ein Notensystem für Studierende.

Erstellen wir eine Map, bei der der Schlüssel vom Typ String ist, der den Namen des Studierenden repräsentiert, und der Wert vom Typ Integer ist, der die Note des Studierenden darstellt. Auf diese Weise können Sie Studierenden Noten zuweisen und die Note einer bestimmten Person einfach über den Schlüssel abrufen:

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

Stellen wir uns nun vor, wir sollen die Noten von Mike und Alice abrufen und anschließend vergleichen. Dies lässt sich einfach mit den oben erlernten Methoden umsetzen. Im folgenden Code wird dies demonstriert:

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

Der ternäre Operator sowie die Methode compareTo() der Wrapper-Klasse Integer wurden verwendet. Falls dies unklar ist, kann es wie folgt erläutert werden:

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

Betrachten wir nun den Fall, dass alle Studierenden mit einer Note höher als 7 (ohne 7) gesammelt werden sollen. Dies wird interessant, und ich erläutere Ihnen jetzt, wie dies umgesetzt werden kann!

Iteration durch die Map

Das Durchlaufen von Elementen in einer Map in Java kann mit verschiedenen Methoden erfolgen, die von der Map-Schnittstelle und deren Implementierungen bereitgestellt werden. Hier sind mehrere Möglichkeiten, eine Map zu durchlaufen:

Iteration über Schlüssel (keySet()): Die Methode keySet() gibt eine Menge aller Schlüssel in der Map zurück. Mit dieser Menge können Sie über die Schlüssel iterieren und die entsprechenden Werte abrufen.

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

Iteration über Werte (values()): Die Methode values() gibt eine Collection aller Werte im Map zurück. Diese Collection kann zum Iterieren über die Werte verwendet werden.

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

Iteration über Schlüssel-Wert-Paare (entrySet()): Die Methode entrySet() gibt eine Menge von Map.Entry-Objekten zurück, die Schlüssel-Wert-Paare repräsentieren. Dies ermöglicht das direkte Iterieren über die Paare.

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

Eine genauere Betrachtung dieses Themas. Anfangs kann es extrem komplex erscheinen, dies zu verstehen, aber es ist nicht notwendig, sich mit den Details der Funktionsweise zu beschäftigen, da die Syntax immer gleich bleibt.

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

Mit dem entry-Objekt ist es möglich, gleichzeitig auf den Schlüssel und den Wert in der Map zuzugreifen. Im Folgenden wird die zuvor gestellte Aufgabe mithilfe des Entry Sets gelöst: Alle Studenten mit einer Note höher als 7 sollen ermittelt werden. Dazu erfolgt eine Überprüfung mit entry.getValue(), und bei passenden Studenten werden deren Schlüssel in eine zuvor erstellte ArrayList übernommen:

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

So können Sie durch die Map iterieren und die gewünschte Liste von Studierenden finden, die die Prüfung bestanden haben!

Das Entry-Set ist ein sehr nützliches Werkzeug, da es verschiedene Möglichkeiten bietet, mit einer Schleife durch die Map zu iterieren und dabei Zugriff auf sowohl den Schlüssel als auch den Wert zu haben.

Im nächsten Kapitel werden wir uns damit beschäftigen, wie HashMap, das wir in diesem Kapitel so intensiv verwendet haben, tatsächlich funktioniert!

War alles klar?

Danke für Ihr Feedback!

Abschnitt 3. Kapitel 1

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Swipe um das Menü anzuzeigen

Wir besprechen das Map-Interface in Java. Das Map-Interface ist Teil des Java Collections Framework und definiert Methoden zur Arbeit mit Daten in Form von Schlüssel-Wert-Paaren.

Hier ist die Definition:

Zunächst die Deklaration und Methoden:

Main.java


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

Hier sehen Sie, dass in den Generics oder Diamantklammern zwei Werte angegeben werden:

Der Wert K entspricht dem Datentyp des Schlüssels;
Der Wert V entspricht dem Datentyp des Werts.

Somit geben wir beim Deklarieren dieser Datenstruktur die Datentypen unserer Schlüssel-Wert-Paare an.

Nun betrachten wir die in der Map -Schnittstelle definierten Methoden.

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): gibt den Wert zurück, dem der angegebene Schlüssel zugeordnet ist, oder null, wenn diese Map keine Zuordnung für den Schlüssel enthält.

Hier wird der Schlüssel angegeben, um den zugehörigen Wert abzurufen.

Abruf des Werts mit Schlüssel 2:

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): gibt true zurück, wenn die Map eine Zuordnung für den angegebenen Schlüssel enthält;
boolean containsValue(Object value): gibt true zurück, wenn die Map einen oder mehrere Schlüssel enthält, die dem angegebenen Wert zugeordnet sind.

Ein Beispiel:

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(): Gibt true zurück, wenn dieses Map keine Schlüssel-Wert-Zuordnungen enthält;
V remove(Object key): Entfernt die Zuordnung für den angegebenen Schlüssel aus diesem Map, falls vorhanden, und gibt den vorherigen Wert zurück.

Wie bei anderen Datenstrukturen können Sie auch im Map Elemente entfernen.

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

Somit können wir Elemente nach Schlüssel entfernen.

Grundlegende Methoden zur Verwaltung von Maps

Als Nächstes gibt es Methoden, die Ihnen bereits bekannt sind, die ich ohne Beispiele auflisten werde. Es bleiben jedoch auch noch interessante Methoden übrig.

Beginnen wir mit den Grundlagen:

void clear(): entfernt alle Elemente aus der Map;
int size(): gibt die Anzahl der Schlüssel-Wert-Zuordnungen in dieser Map zurück;
void putAll(Map<? extends K, ? extends V> m): kopiert alle Zuordnungen aus der angegebenen Map in diese 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 haben wir eine Sammlung von Werten aus der Map erhalten. Nun können wir diese Sammlung in eine ArrayList übertragen:

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

Wir haben eine ArrayList mit Werten aus der Map initialisiert.

Betrachten wir diese Methode:

Set<K> keySet(): gibt eine Set-Ansicht der in dieser Map enthaltenen Schlüssel zurück.

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

Somit können wir auch eine Menge aller Schlüssel aus der Map abrufen.

Damit sind wir mit den Methoden fertig. Schauen wir uns nun die Verwendung der Map sowie praktische Beispiele an:

Verwendung von Map

Eine Struktur wie Schlüssel-Wert hat viele praktische Anwendungsfälle. Betrachten wir die einfachste dieser Strukturen: ein Notensystem für Studierende.

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

Der ternäre Operator sowie die Methode compareTo() der Wrapper-Klasse Integer wurden verwendet. Falls dies unklar ist, kann es wie folgt erläutert werden:

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

Iteration durch die 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);
        }
    }
}

Iteration über Werte (values()): Die Methode values() gibt eine Collection aller Werte im Map zurück. Diese Collection kann zum Iterieren über die Werte verwendet werden.

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

So können Sie durch die Map iterieren und die gewünschte Liste von Studierenden finden, die die Prüfung bestanden haben!

Im nächsten Kapitel werden wir uns damit beschäftigen, wie HashMap, das wir in diesem Kapitel so intensiv verwendet haben, tatsächlich funktioniert!

War alles klar?

Danke für Ihr Feedback!

Abschnitt 3. Kapitel 1

Was ist eine Map?

Methoden

Grundlegende Methoden zur Verwaltung von Maps

Verwendung von Map

Iteration durch die Map

1. Welche Schnittstelle in Java repräsentiert eine Sammlung von Schlüssel-Wert-Paaren?

2. Wie iteriert man mit einer for-each-Schleife durch alle Schlüssel in einer `Map`?

3. Welchen Zweck hat die Methode `values()` in einer `Map`?

4. Welche Methode wird verwendet, um zu prüfen, ob ein bestimmter Schlüssel in einer `Map` vorhanden ist?

5. Welche Methode wird verwendet, um ein Schlüssel-Wert-Paar aus einer `Map` in Java zu entfernen?

Was ist eine Map?

Methoden

Grundlegende Methoden zur Verwaltung von Maps

Verwendung von Map

Iteration durch die Map

1. Welche Schnittstelle in Java repräsentiert eine Sammlung von Schlüssel-Wert-Paaren?

2. Wie iteriert man mit einer for-each-Schleife durch alle Schlüssel in einer `Map`?

3. Welchen Zweck hat die Methode `values()` in einer `Map`?

4. Welche Methode wird verwendet, um zu prüfen, ob ein bestimmter Schlüssel in einer `Map` vorhanden ist?

5. Welche Methode wird verwendet, um ein Schlüssel-Wert-Paar aus einer `Map` in Java zu entfernen?

Was ist eine Map?

Methoden

Grundlegende Methoden zur Verwaltung von Maps

Verwendung von Map

Iteration durch die Map

1. Welche Schnittstelle in Java repräsentiert eine Sammlung von Schlüssel-Wert-Paaren?

2. Wie iteriert man mit einer for-each-Schleife durch alle Schlüssel in einer Map?

3. Welchen Zweck hat die Methode values() in einer Map?

4. Welche Methode wird verwendet, um zu prüfen, ob ein bestimmter Schlüssel in einer Map vorhanden ist?

5. Welche Methode wird verwendet, um ein Schlüssel-Wert-Paar aus einer Map in Java zu entfernen?

Was ist eine Map?

Methoden

Grundlegende Methoden zur Verwaltung von Maps

Verwendung von Map

Iteration durch die Map

1. Welche Schnittstelle in Java repräsentiert eine Sammlung von Schlüssel-Wert-Paaren?

2. Wie iteriert man mit einer for-each-Schleife durch alle Schlüssel in einer Map?

3. Welchen Zweck hat die Methode values() in einer Map?

4. Welche Methode wird verwendet, um zu prüfen, ob ein bestimmter Schlüssel in einer Map vorhanden ist?

5. Welche Methode wird verwendet, um ein Schlüssel-Wert-Paar aus einer Map in Java zu entfernen?

2. Wie iteriert man mit einer for-each-Schleife durch alle Schlüssel in einer `Map`?

3. Welchen Zweck hat die Methode `values()` in einer `Map`?

4. Welche Methode wird verwendet, um zu prüfen, ob ein bestimmter Schlüssel in einer `Map` vorhanden ist?

5. Welche Methode wird verwendet, um ein Schlüssel-Wert-Paar aus einer `Map` in Java zu entfernen?

2. Wie iteriert man mit einer for-each-Schleife durch alle Schlüssel in einer `Map`?

3. Welchen Zweck hat die Methode `values()` in einer `Map`?

4. Welche Methode wird verwendet, um zu prüfen, ob ein bestimmter Schlüssel in einer `Map` vorhanden ist?

5. Welche Methode wird verwendet, um ein Schlüssel-Wert-Paar aus einer `Map` in Java zu entfernen?