CodeGym /Java Blog /Random-IT /LinkedHashMap in Java
John Squirrels
Livello 41
San Francisco

LinkedHashMap in Java

Pubblicato nel gruppo Random-IT

Cos'è LinkedHashMap in Java?

La classe LinkedHashMap del framework Collections è l' implementazione Hashtable e LinkedList dell'interfaccia Map . Memorizza le sue voci in una Hashtable e utilizza internamente un elenco doppiamente collegato per mantenere l'ordine di inserimento. Questa LinkedList definisce l'ordine di inserimento che è l'ordine in cui le chiavi sono state inserite nella Map . HashMap ha fornito il vantaggio di inserimento , ricerca ed eliminazione rapidi , ma in LinkedHashMap l'implementazione di LinkedList mantiene anche l'ordine di inserimento. LinkedHashMap in Java - 1

Caratteristiche di LinkedHashMap

  1. Contiene valori basati sulla chiave.
  2. Contiene elementi unici.
  3. Potrebbe avere una chiave nulla e più valori nulli.
  4. Non è sincronizzato.
  5. Mantiene l'ordine di inserimento che rende l'iterazione più costosa.

Fattori di prestazione

Le prestazioni di LinkedHashMap dipendono principalmente da due fattori descritti di seguito.

Capacità

La capacità indica il numero di voci che può memorizzare. La capacità predefinita è 16 se non viene fornito alcun parametro. Fattore di carico Il fattore di carico significa che ogni volta che HashMap viene popolata a una percentuale specifica fornita come parametro, viene creata una nuova HashMap di dimensioni doppie e tutte le voci vengono spostate in questa nuova. Il fattore di carico predefinito per una HashMap è 0,75 . È noto anche come rapporto di riempimento .

Dichiarazione di LinkedHashMap

Per creare un LinkedHashMap , innanzitutto dobbiamo importare il pacchetto, che è java.util.LinkedHashMap .

LinkedHashMap<Key, Value> lhm = new LinkedHashMap<>(12, 0.5f);
Qui, Chiave è il tipo di chiavi nella mappa. Valore è il tipo di valori mappati nella mappa. 12 è la capacità, il che significa che memorizzerà 12 voci nella mappa. 0,5f è il fattore di carico, il che significa che quando viene popolato il 50%, verrà creata una nuova mappa e spostati tutti i valori in questa nuova.

Metodi comuni di LinkedHashMap

Ecco un elenco di alcuni metodi comuni di LinkedHashMap .
Metodi Descrizione
chiaro() Rimuove tutte le mappature nella mappa.
contieneValore(Valore oggetto) Restituisce vero se la mappa associa la chiave al valore specificato.
set di voci() Restituisce la vista Imposta delle mappature nella mappa.
get(Chiave oggetto) Restituisce il valore rispetto alla chiave specificata o null se non viene specificata alcuna chiave.
mazzo di chiavi() Restituisce la vista Imposta delle chiavi nella mappa.
valori() Restituisce la vista Raccolta dei valori nella mappa.
getOrDefault(Chiave oggetto, V defaultValue) Restituisce il valore a cui è associata la chiave specificata o defaultValue se non è associata alcuna chiave.

Esempio di LinkedHasMap


import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {
        // Creating a LinkedHashMap of odd numbers
        LinkedHashMap<String, Integer> oddNumbers = new LinkedHashMap<>();
        // Using the put() method
        oddNumbers.put("One", 1);
        oddNumbers.put("Three", 3);
        System.out.println("LinkedHashMap1: " + oddNumbers);

        // Creating another LinkedHashMap
        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();
        numbers.put("Two", 2);
        // Using putAll() method
        numbers.putAll(oddNumbers);
        System.out.println("LinkedHashMap2: " + numbers);
        
        // Using entrySet() method
        System.out.println("Key/Value mappings: " + numbers.entrySet());

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

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

        // Using getOrDefault() method
        int value2 = numbers.getOrDefault("Five", 5);
        System.out.println("Returned Number: " + value2);
        
        // Using remove() method
        int value = numbers.remove("Two");
        System.out.println("Removed value: " + value);
        
        // Using entrySet() method
        System.out.println("Key/Value mappings: " + numbers.entrySet());
    }
}

Produzione

LinkedHashMap1: {Uno=1, Tre=3} LinkedHashMap2: {Due=2, Uno=1, Tre=3} Mappature chiave/valore: [Due=2, Uno=1, Tre=3] Chiavi: [Due, Uno , Tre] Valori: [2, 1, 3] Numero restituito: 3 Numero restituito: 5 Valore rimosso: 2 Mappature chiave/valore: [Uno=1, Tre=3]

LinkedHashMap vs HashMap

Vediamo alcune differenze tra loro, considerando che entrambi implementano l' interfaccia Map .
  1. LinkedHashMap mantiene l'ordine di inserimento poiché implementa internamente l'elenco doppiamente collegato.
  2. LinkedHashMap necessita di più spazio di archiviazione poiché implementa LinkedList .
  3. Per quanto riguarda le prestazioni, LinkedHashMap è più lento di HashMap .

Conclusione

Ci auguriamo che tu comprenda la classe LinkedHashMap in Java, i suoi diversi metodi e la loro implementazione. Sentiti libero di esercitarti e di tornare ogni volta che hai bisogno di maggiore assistenza. Buon apprendimento!
Commenti
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION