Java EnumMap meistern: Effizientes Key-Value-Mapping mit Enums

Java EnumMap

In diesem Tutorial lernen wir die Java EnumMap-Klasse und ihre Operationen anhand von Beispielen kennen.

Die EnumMap-Klasse des Java Collections Framework stellt eine Map-Implementierung für Elemente eines Enums bereit.

In EnumMap werden Enum-Elemente als Schlüssel verwendet. Sie implementiert das Map-Interface.

Bevor wir über EnumMap lernen, stellen Sie sicher, dass Sie über Java Enums Bescheid wissen.

EnumMap erstellen

Um eine Enum Map zu erstellen, müssen wir zuerst das java.util.EnumMap-Paket importieren. Nach dem Import können wir Enum Maps in Java wie folgt erstellen.

 enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE } EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);

Im obigen Beispiel haben wir eine Enum Map namens sizes erstellt.

Hier:

Size - Schlüssel des Enums, die auf Werte mappen
Integer - Werte der Enum Map, assoziiert mit den entsprechenden Schlüsseln

Methoden von EnumMap

Die EnumMap-Klasse stellt Methoden bereit, die es uns ermöglichen, verschiedene Operationen auf Enum Maps durchzuführen.

Elemente in EnumMap einfügen

put() - fügt das angegebene Schlüssel/Wert-Mapping (Eintrag) zur Enum Map hinzu
putAll() - fügt alle Einträge einer angegebenen Map zu dieser Map hinzu

Zum Beispiel,

 import java.util.EnumMap; class Main { enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE } public static void main(String[] args) { // Erstellen einer EnumMap des Size Enums EnumMap<Size, Integer> sizes1 = new EnumMap<>(Size.class); // Verwenden der put() Methode sizes1.put(Size.SMALL, 28); sizes1.put(Size.MEDIUM, 32); System.out.println("EnumMap1: " + sizes1); EnumMap<Size, Integer> sizes2 = new EnumMap<>(Size.class); // Verwenden der putAll() Methode sizes2.putAll(sizes1); sizes2.put(Size.LARGE, 36); System.out.println("EnumMap2: " + sizes2); } }

Ausgabe

 EnumMap1: {SMALL=28, MEDIUM=32} EnumMap2: {SMALL=28, MEDIUM=32, LARGE=36}

Im obigen Beispiel haben wir die putAll() Methode verwendet, um alle Elemente der Enum Map sizes1 in eine Enum Map von sizes2 einzufügen.

Es ist auch möglich, Elemente aus anderen Maps wie HashMap, TreeMap, etc. in eine Enum Map einzufügen mittels putAll(). Allerdings sollten alle Maps vom gleichen Enum-Typ sein.

Auf EnumMap-Elemente zugreifen

1. Mit entrySet(), keySet() und values()

entrySet() - gibt ein Set aller Schlüssel/Wert-Mappings (Einträge) einer Enum Map zurück
keySet() - gibt ein Set aller Schlüssel einer Enum Map zurück
values() - gibt ein Set aller Werte einer Enum Map zurück

Zum Beispiel,

 import java.util.EnumMap; class Main { enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE } public static void main(String[] args) { // Erstellen einer EnumMap des Size Enums EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class); sizes.put(Size.SMALL, 28); sizes.put(Size.MEDIUM, 32); sizes.put(Size.LARGE, 36); sizes.put(Size.EXTRALARGE, 40); System.out.println("EnumMap: " + sizes); // Verwenden der entrySet() Methode System.out.println("Key/Value mappings: " + sizes.entrySet()); // Verwenden der keySet() Methode System.out.println("Keys: " + sizes.keySet()); // Verwenden der values() Methode System.out.println("Values: " + sizes.values()); } }

Ausgabe

 EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40} Key/Value mappings: [SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40] Keys: [SMALL, MEDIUM, LARGE, EXTRALARGE] Values: [28, 32, 36, 40]

2. Mit der get() Methode

Die get() Methode gibt den Wert zurück, der mit dem angegebenen Schlüssel assoziiert ist. Sie gibt null zurück, falls der angegebene Schlüssel nicht gefunden wird.

Zum Beispiel,

 import java.util.EnumMap; class Main { enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE } public static void main(String[] args) { // Erstellen einer EnumMap des Size Enums EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class); sizes.put(Size.SMALL, 28); sizes.put(Size.MEDIUM, 32); sizes.put(Size.LARGE, 36); sizes.put(Size.EXTRALARGE, 40); System.out.println("EnumMap: " + sizes); // Verwenden der get() Methode int value = sizes.get(Size.MEDIUM); System.out.println("Value of MEDIUM: " + value); } }

Ausgabe

 EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40} Value of MEDIUM: 32

EnumMap-Elemente entfernen

remove(key) - gibt den Eintrag zurück und entfernt ihn, der mit dem angegebenen Schlüssel assoziiert ist
remove(key, value) - entfernt den Eintrag nur falls der angegebene Schlüssel auf den angegebenen Wert mappte und gibt boolean zurück

Zum Beispiel,

 import java.util.EnumMap; class Main { enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE } public static void main(String[] args) { // Erstellen einer EnumMap des Size Enums EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class); sizes.put(Size.SMALL, 28); sizes.put(Size.MEDIUM, 32); sizes.put(Size.LARGE, 36); sizes.put(Size.EXTRALARGE, 40); System.out.println("EnumMap: " + sizes); // Verwenden der remove() Methode int value = sizes.remove(Size.MEDIUM); System.out.println("Removed Value: " + value); boolean result = sizes.remove(Size.SMALL, 28); System.out.println("Is the entry {SMALL=28} removed? " + result); System.out.println("Updated EnumMap: " + sizes); } }

Ausgabe

 EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40} Removed Value: 32 Is the entry {SMALL=28} removed? True Updated EnumMap: {LARGE=36, EXTRALARGE=40}

EnumMap-Elemente ersetzen

replace(key, value) - ersetzt den Wert, der mit dem angegebenen key assoziiert ist, durch den neuen value
replace(key, old, new) - ersetzt den old Wert durch den new Wert nur falls der old Wert bereits mit dem angegebenen key assoziiert ist
replaceAll(function) - ersetzt jeden Wert der Map mit dem Ergebnis der angegebenen function

 import java.util.EnumMap; class Main { enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE } public static void main(String[] args) { // Erstellen einer EnumMap des Size Enums EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class); sizes.put(Size.SMALL, 28); sizes.put(Size.MEDIUM, 32); sizes.put(Size.LARGE, 36); sizes.put(Size.EXTRALARGE, 40); System.out.println("EnumMap: " + sizes); // Verwenden der replace() Methode sizes.replace(Size.MEDIUM, 30); sizes.replace(Size.LARGE, 36, 34); System.out.println("EnumMap using replace(): " + sizes); // Verwenden der replaceAll() Methode sizes.replaceAll((key, oldValue) -> oldValue + 3); System.out.println("EnumMap using replaceAll(): " + sizes); } }

Ausgabe

 EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40} EnumMap using replace(): {SMALL=28, MEDIUM=30, LARGE=34, EXTRALARGE=40} EnumMap using replaceAll(): {SMALL=31, MEDIUM=33, LARGE=37, EXTRALARGE=43}

Im obigen Programm beachten Sie die Anweisung

 sizes.replaceAll((key, oldValue) -> oldValue + 3);

Hier greift die Methode auf alle Einträge der Map zu. Sie ersetzt dann alle Werte mit den neuen Werten, die durch die Lambda-Ausdrücke bereitgestellt werden.

Weitere Methoden

Methode	Beschreibung
`clone()`	Erstellt eine Kopie der `EnumMap`
`containsKey()`	Sucht die `EnumMap` nach dem angegebenen Schlüssel und gibt boolean zurück
`containsValue()`	Sucht die `EnumMap` nach dem angegebenen Wert und gibt boolean zurück
`size()`	Gibt die Größe der `EnumMap` zurück
`clear()`	Entfernt alle Einträge aus der `EnumMap`

EnumSet Vs. EnumMap

Sowohl die EnumSet- als auch die EnumMap-Klasse bieten Datenstrukturen zum Speichern von Enum-Werten. Allerdings gibt es einige wesentliche Unterschiede zwischen ihnen.

Enum Set wird intern als Bitsequenz repräsentiert, während die Enum Map intern als Arrays repräsentiert wird.
Enum Set wird mit vordefinierten Methoden wie allOf(), noneOf(), of() etc. erstellt. Eine Enum Map wird jedoch über ihren Konstruktor erstellt.

Cloneable und Serializable Interfaces

Die EnumMap-Klasse implementiert auch Cloneable und Serializable Interfaces.

Cloneable Interface

Es erlaubt der EnumMap-Klasse, eine Kopie von Instanzen der Klasse zu erstellen.

Serializable Interface

Wann immer Java-Objekte über ein Netzwerk übertragen werden müssen, müssen Objekte in Bits oder Bytes konvertiert werden. Das ist der Fall, weil Java-Objekte nicht direkt über das Netzwerk übertragen werden können.

Das Serializable Interface erlaubt Klassen, serialisiert zu werden. Das bedeutet, Objekte von Klassen, die Serializable implementieren, können in Bits oder Bytes konvertiert werden.

Java WeakHashMap – Verständnis, Nutzung und Schlüsselunterschiede Java SortedMap-Interface: Überblick, Methoden und TreeMap-Implementierung

Java