LinkedHashMap Java

In questo tutorial, impareremo tramite esempi la classe LinkedHashMap di Java e le sue operazioni.

La classe LinkedHashMap della Java Collection Framework fornisceInterfaccia Mapdell'implementazione di tabella hash e lista collegata.

LinkedHashMap ereditaHashMapClasse, per memorizzare le sue voci in una tabella hash. Interna alla tabella hash mantiene una doppia lista collegata tra tutte le voci per ordinare gli elementi.

Creare una LinkedHashMap

Per creare una doppia lista collegata, dobbiamo prima importare il pacchetto java.util.LinkedHashMap. Dopo aver importato il pacchetto, possiamo utilizzare i seguenti metodi per creare una doppia lista collegata in Java.

//La capacità iniziale di LinkedHashMap è 8, il fattore di carico è 0.6
LinkedHashMap<Key, Value> numbers = new LinkedHashMap<>(8, 0.6f);

Nel codice sopra, abbiamo creato una LinkedHashMap chiamata numbers.

Qui:

• Key - identificatore unico utilizzato per associare ogni elemento (valore) nella mappa

• Value - elemento associato alla chiave nella mappa

Attenzione a questa parte: new LinkedHashMap<>(8, 0.6). Qui, il primo parametro è capacity, il secondo parametro è loadFactor.

• capacity - La capacità di questa doppia lista collegata è 8. Questo significa che può memorizzare 8 elementi.

• loadFactor- Il fattore di carico di questa doppia lista collegata è 0.6. Questo significa che ogni volta che la mappa viene riempita al 60%, gli elementi vengono spostati in una nuova tabella hash, la cui dimensione è il doppio di quella dell'originale.

Capacità predefinita e fattore di carico

Non è necessario definire la capacità e il fattore di carico per creare una doppia lista collegata. Ad esempio:

//HaMap con capacità predefinita e fattore di carico
LinkedHashMap<Key, Value> numbers1 = new LinkedHashMap<>();

Di default,

• La capacità della coda bidirezionale sarà 16

• Il fattore di carico sarà 0.75

AttenzioneEsempio

// LinkedHashMap con ordine specificato
LinkedHashMap<Key, Value> numbers2 = new LinkedHashMap<>(capacity, loadFactor, accessOrder);

Qui accessOrder è un valore booleano. Il valore predefinito è false. In questo caso, gli elementi della coda bidirezionale saranno ordinati in base all'ordine di inserimento.

Ma se il valore di accessOrder è true, gli elementi della coda bidirezionale saranno ordinati in base all'ordine di accesso più recente.

// Creando LinkedHashMap da un altro elenco bidirezionale

Di seguito è riportato un elenco bidirezionale che contiene tutti gli elementi di altre mappe.

import java.util.LinkedHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　// Creando LinkedHashMap di numeri pari
　　　　　　　　LinkedHashMap<String, Integer> evenNumbers = new LinkedHashMap<>();
　　　　　　　　evenNumbers.put("Two", 2)
　　　　　　　　evenNumbers.put("Four", 4)
　　　　　　　　System.out.println("LinkedHashMap1: " + evenNumbers);
　　　　　　　　// Creando LinkedHashMap da un altro LinkedHashMap
　　　　　　　　LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>(evenNumbers);
　　　　　　　　numbers.put("Three", 3);
　　　　　　　　System.out.println("LinkedHashMap2: " + numbers);
　　　　}
}

Risultato di output

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

Metodi di LinkedHashMap

Questa classe LinkedHashMap ci fornisce metodi vari per operare sulla mappa.

Inserire l'elemento in LinkedHashMap

• put() - Inserisce la mappa chiave/valore specificata nella mappa

• putAll() - Inserisce tutti gli elementi della mappa specificata in questa mappa

• putIfAbsent() - Se la mappa non contiene la chiave specificata, inserisce la mappa chiave/valore specificata

Ad esempio,

import java.util.LinkedHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　// Creando LinkedHashMap di numeri pari
　　　　　　　　LinkedHashMap<String, Integer> evenNumbers = new LinkedHashMap<>();
　　　　　　　　// Utilizzare put()
　　　　　　　　evenNumbers.put("Two", 2)
　　　　　　　　evenNumbers.put("Four", 4)
　　　　　　　　System.out.println("LinkedHashMap originale: " + evenNumbers)
　　　　　　　　// Utilizzare putIfAbsent()
　　　　　　　　evenNumbers.putIfAbsent("Six", 6)
　　　　　　　　System.out.println("LinkedHashMap aggiornato(): " + evenNumbers)
　　　　　　　　// Creare LinkedHashMap di numbers
　　　　　　　　LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();
　　　　　　　　numbers.put("One", 1);
　　　　　　　　// Utilizzare putAll()
　　　　　　　　numbers.putAll(evenNumbers)
　　　　　　　　System.out.println("Nuovo LinkedHashMap: " + numbers)
　　　　}
}

Risultato di output

LinkedHashMap originale: {Two=2, Four=4}
LinkedHashMap aggiornato: {Two=2, Four=4, Six=6}
Nuovo LinkedHashMap: {One=1, Two=2, Four=4, Six=6}

Accedere agli elementi di LinkedHashMap

1. Utilizzare entrySet(), keySet() e values()

• entrySet() - Restituisce l'insieme di tutte le mappature chiave/valore

• keySet() - Restituisce l'insieme di tutte le chiavi della mappa

• values() - Restituisce l'insieme di tutti i valori della mappa

Ad esempio,

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);
　　　　　　　　// Utilizzare entrySet()
　　　　　　　　System.out.println("Mappatura Key/Value: " + numbers.entrySet())
　　　　　　　　// Utilizzare keySet()
　　　　　　　　System.out.println("Keys (chiavi): " + numbers.keySet())
　　　　　　　　// Utilizzare values()
　　　　　　　　System.out.println("Values (valori): " + numbers.values())
　　　　}
}

Risultato di output

LinkedHashMap: {One=1, Two=2, Three=3}
Mappatura Key/Value: [One=1, Two=2, Three=3]
Keys (chiavi): [One, Two, Three]
Values (valori): [1, 2, 3]

2. Utilizzare get() e getOrDefault()

• get() - Restituisce il valore associato alla chiave specificata. Se non viene trovata la chiave, restituisce null.

• getOrDefault() - Restituisce il valore associato alla chiave specificata. Se non viene trovata la chiave, restituisce il valore predefinito specificato.

Ad esempio,

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);
　　　　　　　　//Utilizzo di get()
　　　　　　　　int value1 = numbers.get("Three");
　　　　　　　　System.out.println("Restituisce il numero: " + value1);
　　　　　　　　//Utilizzo di getOrDefault()
　　　　　　　　int value2 = numbers.getOrDefault("Five", 5);
　　　　　　　　System.out.println("Restituisce il numero: " + value2);
　　　　}
}

Risultato di output

LinkedHashMap: {One=1, Two=2, Three=3}
Restituisce il numero: 3
Restituisce il numero: 5

Rimozione degli elementi di LinkedHashMap

• remove(key) - Restituisce e rimuove l'elemento associato alla chiave specificata.

• remove(key, value) - Rimuove l'elemento dalla mappatura solo se la chiave specificata key è mappata al valore specificato value e restituisce un valore booleano.

Ad esempio,

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);
　　　　　　　　//Metodo di rimozione con un solo parametro
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("Valore rimosso: " + value);
　　　　　　　　//Metodo di rimozione con due parametri
　　　　　　　　boolean result = numbers.remove("Three", 3);
　　　　　　　　System.out.println("È stato rimosso l'elemento 3? " + result);
　　　　　　　　System.out.println("LinkedHashMap aggiornato: " + numbers);
　　　　}
}

Risultato di output

LinkedHashMap: {One=1, Two=2, Three=3}
Elimina valore: 2
L'entrata 3 è stata eliminata? True
LinkedHashMap aggiornato: {One=1}

Altri metodi di LinkedHashMap

Differenze tra LinkedHashMap e HashMap

LinkedHashMap e HashMap implementano l'interfaccia Map. Tuttavia, esistono alcune differenze tra loro.

• LinkedHashMap mantiene internamente una coda a doppio cappio. Pertanto, mantiene l'ordine di inserimento degli elementi.

• La classe LinkedHashMap richiede più spazio di archiviazione rispetto a HashMap. Questo è perché LinkedHashMap mantiene internamente una coda.

• La performance di LinkedHashMap è più lenta rispetto a HashMap.