Java-EnumMap

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

Der EnumMap Klasse des Java Collections Framework stellt eine Map-Implementierung für Elemente einer Enumeration bereit.

In EnumMap , Enum-Elemente werden als Schlüssel verwendet . Es implementiert die Map-Schnittstelle.

Bevor wir etwas über EnumMap erfahren , informieren Sie sich unbedingt über die Java-Enums.

Eine EnumMap erstellen

Um eine Enum-Map zu erstellen, müssen wir die java.util.EnumMap importieren Paket zuerst. Sobald wir das Paket importiert haben, können wir hier Enum-Maps in Java erstellen.

enum Size {
    SMALL, MEDIUM, LARGE, EXTRALARGE
}

EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);

Im obigen Beispiel haben wir eine Enum-Map mit dem Namen sizes erstellt .

Hier,

Größe - Schlüssel der Aufzählung, die Werten zugeordnet sind
Ganzzahl - Werte der Enum-Map, die den entsprechenden Schlüsseln zugeordnet ist

Methoden von EnumMap

Die EnumMap Die Klasse stellt Methoden bereit, mit denen wir verschiedene Elemente auf den Enum-Maps ausführen können.

Elemente in EnumMap einfügen

put() - fügt die angegebene Schlüssel/Wert-Zuordnung (Eintrag) in die Enum-Zuordnung ein
putAll() - fügt alle Einträge einer angegebenen Map in diese Map ein

Zum Beispiel

import java.util.EnumMap;

class Main {

    enum Size {
        SMALL, MEDIUM, LARGE, EXTRALARGE
    }
    public static void main(String[] args) {

        // Creating an EnumMap of the Size enum
        EnumMap<Size, Integer> sizes1 = new EnumMap<>(Size.class);

        // Using the put() Method
        sizes1.put(Size.SMALL, 28);
        sizes1.put(Size.MEDIUM, 32);
        System.out.println("EnumMap1: " + sizes1);

        EnumMap<Size, Integer> sizes2 = new EnumMap<>(Size.class);

        // Using the putAll() Method
        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 den putAll() verwendet Methode zum Einfügen aller Elemente einer Aufzählungskarte sizes1 zu einer Aufzählungskarte von sizes2 .

Es ist auch möglich, Elemente aus anderen Karten wie HashMap einzufügen , TreeMap , etc. zu einer Enum-Map mit putAll() . Alle Maps sollten jedoch vom gleichen Enum-Typ sein.

Zugriff auf EnumMap-Elemente

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

entrySet() - gibt einen Satz aller Schlüssel/Werte-Mappings (Einträge) einer Enum-Map zurück
keySet() - gibt einen Satz aller Schlüssel einer Enum-Map zurück
values() - gibt eine Menge 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) {

        // Creating an EnumMap of the Size enum
        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);

        // Using the entrySet() Method
        System.out.println("Key/Value mappings: " + sizes.entrySet());

        // Using the keySet() Method
        System.out.println("Keys: " + sizes.keySet());

        // Using the values() Method
        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. Verwenden der get()-Methode

Die get() -Methode gibt den Wert zurück, der dem angegebenen Schlüssel zugeordnet ist. Es gibt null zurück wenn 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) {

        // Creating an EnumMap of the Size enum
        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);

        // Using the get() Method
        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 mit dem angegebenen Schlüssel verknüpften Eintrag aus der Map zurück und entfernt ihn
remove(key, value) - Entfernt den Eintrag nur dann aus der Zuordnung, wenn der angegebene Schlüssel dem angegebenen Wert zugeordnet ist, und gibt einen booleschen Wert zurück

Zum Beispiel

import java.util.EnumMap;

class Main {

    enum Size {
        SMALL, MEDIUM, LARGE, EXTRALARGE
    }
    public static void main(String[] args) {

        // Creating an EnumMap of the Size enum
        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);

        // Using the remove() Method
        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 dem angegebenen Schlüssel zugeordnet ist durch den neuen Wert
replace(key, old, new) - ersetzt die alte Wert mit new Wert nur, wenn der old Wert ist bereits mit dem angegebenen Schlüssel verknüpft
replaceAll(function) - ersetzt jeden Wert der Karte durch das Ergebnis der angegebenen Funktion

import java.util.EnumMap;

class Main {

    enum Size {
        SMALL, MEDIUM, LARGE, EXTRALARGE
    }
    public static void main(String[] args) {

        // Creating an EnumMap of the Size enum
        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);

        // Using the replace() Method
        sizes.replace(Size.MEDIUM, 30);
        sizes.replace(Size.LARGE, 36, 34);
        System.out.println("EnumMap using replace(): " + sizes);

        // Using the replaceAll() Method
        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}

Beachten Sie im obigen Programm die Anweisung

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

Dabei greift die Methode auf alle Einträge der Map zu. Anschließend werden alle Werte durch die neuen Werte ersetzt, die von den Lambda-Ausdrücken bereitgestellt werden.

Andere Methoden

zurück zurück

Methode	Beschreibung
`clone()`	Erzeugt eine Kopie von `EnumMap`
`containsKey()`	Sucht den `EnumMap` für den angegebenen Schlüssel und gibt ein boolesches Ergebnis
`containsValue()`	Sucht den `EnumMap` für den angegebenen Wert und gibt ein boolesches Ergebnis
`size()`	Gibt die Größe des `EnumMap` zurück
`clear()`	Entfernt alle Einträge aus `EnumMap`

EnumSet vs. EnumMap

Sowohl das EnumSet als auch EnumMap Die Klasse stellt Datenstrukturen zum Speichern von Aufzählungswerten bereit. Es gibt jedoch einige große Unterschiede zwischen ihnen.

Ein Enum-Set wird intern als eine Folge von Bits dargestellt, während die Enum-Map intern als Arrays dargestellt wird.
Enum-Set wird mit seinen vordefinierten Methoden wie allOf() erstellt , noneOf() , of() usw. Eine Aufzählungszuordnung wird jedoch mithilfe ihres Konstruktors erstellt.

Klonbare und serialisierbare Schnittstellen

Der EnumMap Klasse implementiert auch Cloneable und Serializable Schnittstellen.

Klonbare Oberfläche

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

Serialisierbare Schnittstelle

Wann immer Java-Objekte über ein Netzwerk übertragen werden müssen, müssen Objekte in Bits oder Bytes umgewandelt werden. Dies liegt daran, dass Java-Objekte nicht über das Netzwerk übertragen werden können.

Der Serializable -Schnittstelle ermöglicht die Serialisierung von Klassen. Damit sind Objekte der Klassen gemeint, die Serializable implementieren kann in Bits oder Bytes umgewandelt werden.

Java-WeakHashMap Java SortedMap-Schnittstelle

Java