Java LinkedHashMap

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

Der LinkedHashMap -Klasse des Java-Collections-Frameworks stellt die Implementierung der Hash-Tabelle und der verketteten Liste der Map-Schnittstelle bereit.

Die LinkedHashMap -Schnittstelle erweitert die HashMap-Klasse, um ihre Einträge in einer Hash-Tabelle zu speichern. Es unterhält intern eine doppelt verknüpfte Liste unter all seinen Einträgen, um seine Einträge zu ordnen.

Erstellen einer LinkedHashMap

Um eine verknüpfte Hashmap zu erstellen, müssen wir den java.util.LinkedHashMap importieren Paket zuerst. Sobald wir das Paket importiert haben, können wir wie folgt verknüpfte Hashmaps in Java erstellen.

// LinkedHashMap with initial capacity 8 and load factor 0.6
LinkedHashMap<Key, Value> numbers = new LinkedHashMap<>(8, 0.6f);

Im obigen Code haben wir eine verknüpfte Hashmap mit dem Namen numbers erstellt .

Hier,

Schlüssel - eine eindeutige Kennung, die verwendet wird, um jedes Element (Wert) in einer Zuordnung zuzuordnen
Wert - Elemente, die den Schlüsseln in einer Karte zugeordnet sind

Beachten Sie den Teil new LinkedHashMap<>(8, 0.6) . Hier ist der erste Parameter Kapazität und der zweite Parameter ist loadFactor .

Kapazität - Die Kapazität dieser verknüpften Hashmap beträgt 8. Das heißt, sie kann 8 Einträge speichern.
loadFactor - Der Ladefaktor dieser verlinkten Hashmap beträgt 0,6. Das heißt, immer wenn unsere Hash-Map zu 60 % gefüllt ist, werden die Einträge in eine neue Hash-Tabelle verschoben, die doppelt so groß ist wie die ursprüngliche Hash-Tabelle.

Standardkapazität und Ladefaktor

Es ist möglich, eine verknüpfte Hashmap zu erstellen, ohne deren Kapazität und Lastfaktor zu definieren. Zum Beispiel

//LinkedHashMap with default capacity and load factor
LinkedHashMap<Key, Value> numbers1 = new LinkedHashMap<>();

Standardmäßig

Die Kapazität der verknüpften Hashmap beträgt 16
der Ladefaktor beträgt 0,75

Hinweis :Die LinkedHashMap Klasse erlaubt es uns auch, die Reihenfolge ihrer Einträge zu definieren. Zum Beispiel

// LinkedHashMap with specified order
LinkedHashMap<Key, Value> numbers2 = new LinkedHashMap<>(capacity, loadFactor, accessOrder);

Hier accessOrder ist ein boolescher Wert. Sein Standardwert ist false . In diesem Fall werden Einträge in der verlinkten Hashmap nach ihrer Insertion Order geordnet.

Wenn jedoch true wird als accessOrder übergeben , werden die Einträge in der verknüpften Hashmap vom zuletzt aufgerufenen zum zuletzt aufgerufenen geordnet.

LinkedHashMap aus anderen Karten erstellen

So können wir eine verknüpfte Hashmap erstellen, die alle Elemente anderer Karten enthält.

import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {
        // Creating a LinkedHashMap of even numbers
        LinkedHashMap<String, Integer> evenNumbers = new LinkedHashMap<>();
        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);
        System.out.println("LinkedHashMap1: " + evenNumbers);

        // Creating a LinkedHashMap from other LinkedHashMap
        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>(evenNumbers);
        numbers.put("Three", 3);
        System.out.println("LinkedHashMap2: " + numbers);
    }
}

Ausgabe

LinkedHashMap1: {Two=2, Four=4}
LinkedHashMap2: {Two=2, Four=4, Three=3}

Methoden von LinkedHashMap

Die LinkedHashMap Die Klasse stellt Methoden bereit, mit denen wir verschiedene Operationen auf der Karte ausführen können.

Elemente in LinkedHashMap einfügen

put() - fügt die angegebene Schlüssel/Wert-Zuordnung in die Zuordnung ein
putAll() - fügt alle Einträge aus der angegebenen Map in diese Map ein
putIfAbsent() - fügt die angegebene Schlüssel/Wert-Zuordnung in die Map ein, wenn der angegebene Schlüssel nicht in der Map vorhanden ist

Zum Beispiel


import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {
        // Creating LinkedHashMap of even numbers
        LinkedHashMap<String, Integer> evenNumbers = new LinkedHashMap<>();

        // Using put()
        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);
        System.out.println("Original LinkedHashMap: " + evenNumbers);

        // Using putIfAbsent()
        evenNumbers.putIfAbsent("Six", 6);
        System.out.println("Updated LinkedHashMap(): " + evenNumbers);

        //Creating LinkedHashMap of numbers
        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();
        numbers.put("One", 1);

        // Using putAll()
        numbers.putAll(evenNumbers);
        System.out.println("New LinkedHashMap: " + numbers);
    }
}

Ausgabe

Original LinkedHashMap: {Two=2, Four=4}
Updated LinkedHashMap: {Two=2, Four=4, Six=6}
New LinkedHashMap: {One=1, Two=2, Four=4, Six=6}

Zugriff auf LinkedHashMap-Elemente

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

entrySet() - gibt einen Satz aller Schlüssel/Wert-Mappings der Map zurück
keySet() - gibt einen Satz aller Schlüssel der Karte zurück
values() - gibt einen Satz aller Werte der Karte zurück

Zum Beispiel

import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {
        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();

        numbers.put("One", 1);
        numbers.put("Two", 2);
        numbers.put("Three", 3);
        System.out.println("LinkedHashMap: " + numbers);

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

        // Using keySet()
        System.out.println("Keys: " + numbers.keySet());

        // Using values()
        System.out.println("Values: " + numbers.values());
    }
}

Ausgabe

LinkedHashMap: {One=1, Two=2, Three=3}
Key/Value mappings: [One=1, Two=2, Three=3]
Keys: [One, Two, Three]
Values: [1, 2, 3]

2. Verwenden von get() und getOrDefault()

get() - Gibt den Wert zurück, der dem angegebenen Schlüssel zugeordnet ist. Wenn der Schlüssel nicht gefunden wird, wird null zurückgegeben .
getOrDefault() - Gibt den Wert zurück, der dem angegebenen Schlüssel zugeordnet ist. Wenn der Schlüssel nicht gefunden wird, gibt er den angegebenen Standardwert zurück.

Zum Beispiel

import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {

        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();
        numbers.put("One", 1);
        numbers.put("Two", 2);
        numbers.put("Three", 3);
        System.out.println("LinkedHashMap: " + numbers);

        // Using get()
        int value1 = numbers.get("Three");
        System.out.println("Returned Number: " + value1);

        // Using getOrDefault()
        int value2 = numbers.getOrDefault("Five", 5);
        System.out.println("Returned Number: " + value2);
    }
}

Ausgabe

LinkedHashMap: {One=1, Two=2, Three=3}
Returned Number: 3
Returned Number: 5

LinkedHashMap-Elemente entfernt

remove(key) - gibt den mit dem angegebenen Schlüssel verknüpften Eintrag zurück und entfernt ihn von der Karte
remove(key, value) - entfernt den Eintrag nur dann aus der Karte, wenn der angegebene Schlüssel dem angegebenen Wert zugeordnet und einen booleschen Wert zurückgeben

Zum Beispiel

import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {

        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();
        numbers.put("One", 1);
        numbers.put("Two", 2);
        numbers.put("Three", 3);
        System.out.println("LinkedHashMap: " + numbers);

        // remove method with single parameter
        int value = numbers.remove("Two");
        System.out.println("Removed value: " + value);

        // remove method with two parameters
        boolean result = numbers.remove("Three", 3);
        System.out.println("Is the entry Three removed? " + result);

        System.out.println("Updated LinkedHashMap: " + numbers);
    }
}

Ausgabe

LinkedHashMap: {One=1, Two=2, Three=3}
Removed value: 2
Is the entry {Three=3} removed? True
Updated LinkedHashMap: {One=1}

Andere Methoden von LinkedHashMap

Methode	Beschreibung
`clear()`	entfernt alle Einträge aus der Karte
`containsKey()`	überprüft, ob die Map den angegebenen Schlüssel enthält und gibt einen booleschen Wert zurück
`containsValue()`	überprüft, ob die Karte den angegebenen Wert enthält und gibt einen booleschen Wert zurück
`size()`	gibt die Größe der Karte zurück
`isEmpty()`	überprüft, ob die Map leer ist und gibt einen booleschen Wert zurück

LinkedHashMap vs. HashMap

Sowohl die LinkedHashMap und der HashMap implementiert den Map Schnittstelle. Es gibt jedoch einige Unterschiede zwischen ihnen.

LinkedHashMap verwaltet intern eine doppelt verknüpfte Liste. Aus diesem Grund behält es die Einfügungsreihenfolge seiner Elemente bei.
Der LinkedHashMap Klasse benötigt mehr Speicherplatz als HashMap . Das liegt daran, dass LinkedHashMap verwaltet intern verlinkte Listen.
Die Leistung von LinkedHashMap ist langsamer als HashMap .

Java-HashMap Java-WeakHashMap

Java