Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Lernen Was ist eine Map? | Section
Grundlegende Datenstrukturen in Java

Was ist eine Map?

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.

Werfen wir einen Blick auf die Definition:

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

Wir beginnen mit der Deklaration und den Methoden:

Main.java

Main.java


              
1

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

Hier sehen Sie, dass in den Generika 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 zuvor eine Zuordnung für den Schlüssel enthielt, wird der alte Wert ersetzt.

Main.java

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 geben wir den Schlüssel an, um den entsprechenden Wert abzurufen.

Wir rufen nun den Wert mit Schlüssel 2 ab:

Main.java

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 dabei 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.

Sehen wir uns ein Beispiel an:

Main.java

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 in der 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 diese Map keine Schlüssel-Wert-Zuordnungen enthält;

  • V remove(Object key): Entfernt die Zuordnung für den angegebenen Schlüssel aus dieser Map, falls vorhanden, und gibt den vorherigen Wert zurück.

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

Main.java

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 folgen Methoden, die Ihnen bereits bekannt sind, die ich ohne Beispiele aufliste. Es gibt jedoch auch noch interessante Methoden.

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 zu den Methoden, 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

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

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

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.

Wir erstellen eine Map, bei der der Schlüssel vom Typ String ist und den Namen des Studierenden repräsentiert, während der Wert vom Typ Integer ist und die Note des Studierenden darstellt. Auf diese Weise können Sie Noten zuweisen und die Note eines bestimmten Studierenden mithilfe des Schlüssels einfach abrufen:

Main.java

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 leicht mit den oben erlernten Methoden umsetzen. Im Folgenden wird dies im Code implementiert:

Main.java

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 und die Methode compareTo() der Wrapper-Klasse Integer wurden verwendet. Falls unklar ist, wie dies funktioniert, kann es wie folgt erklärt werden:

Main.java

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 wir alle Studierenden mit einer Note höher als 7 (ohne 7) erfassen sollen. Das wird interessant, und ich erkläre Ihnen jetzt, wie das funktioniert!

Iteration durch die Map

Das Iterieren über Elemente in einer Map in Java kann mit verschiedenen Methoden erfolgen, die von der Map-Schnittstelle und ihren Implementierungen bereitgestellt werden. Hier sind mehrere Möglichkeiten, über eine Map zu iterieren:

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

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 Sammlung aller Werte in der Map zurück. Diese Sammlung kann verwendet werden, um über die Werte zu iterieren.

Main.java

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 die direkte Iteration über die Paare.

Main.java

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: Anfangs erscheint dies extrem komplex, jedoch ist es nicht notwendig, die Funktionsweise im Detail zu verstehen, da die Syntax immer gleich bleibt.

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

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

Main.java

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 Schlüssel als auch Wert zu haben.

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

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

2. Wie iteriert man mit einer for-each-Schleife über 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?

question mark

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

Wählen Sie die richtige Antwort aus

question mark

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

Wählen Sie die richtige Antwort aus

question mark

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

Wählen Sie die richtige Antwort aus

question mark

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

Wählen Sie die richtige Antwort aus

question mark

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

Wählen Sie die richtige Antwort aus

War alles klar?

Wie können wir es verbessern?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 13

Fragen Sie AI

expand

Fragen Sie AI

ChatGPT

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

Abschnitt 1. Kapitel 13
some-alt