English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Java 基礎教程

Java Controllo di flusso

Java Array

Java Orientazione agli oggetti (I)

Java Orientazione agli oggetti (II)

Java Orientazione agli oggetti (III)

Java 異常處理

Java List

Java Queue (coda)

Java Map collection

Java Set collection

Java Input/Output (I/O)

Java Reader/Writer

Altri argomenti Java

Java LinkedHashSet

In questo tutorial, impareremo con esempi la classe LinkedHashSet di Java e i suoi metodi.

La classe LinkedHashSet della Java Collection Framework fornisce le funzionalità di tabella hash e elenco collegato.

ImplementaInterfaccia Set.

Gli elementi di HashSet sono memorizzati in modo simile aHashSetnella tabella hash.

Ma HashSet mantiene internamente una doppia lista per tutti i suoi elementi. La lista definisce l'ordine di inserimento degli elementi nella tabella hash.

Creare una HashSet

Per creare HashSet, dobbiamo prima importare il pacchetto java.util.LinkedHashSet.

Dopo aver importato il pacchetto, puoi creare HashSet in Java.

//HaSet con 8 capacità e 0.75 fattore di carico
LinkedHashSet<Integer> numbers = new LinkedHashSet<>(8, 0.75);

Qui, abbiamo creato una HashSet di nomi chiamata numbers.

Attenzione, nella dichiarazione new HashSet<>(8, 0.75). Qui, il primo parametro èCapacità,il secondo parametro èFattore di carico.

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

  • loadFactor- Il fattore di carico di questa HashSet è 0.6. Questo significa che appena la nostra tabella hash è stata riempita al 60%, gli elementi verranno spostati in una nuova tabella hash, la cui dimensione è il doppio di quella della tabella hash originale.

Capacità predefinita e fattore di carico

Puoi creare una HashSet senza definire la sua capacità e il fattore di carico. Ad esempio,

//HaSet con capacità predefinita e fattore di carico
LinkedHashSet<Integer> numbers1 = new LinkedHashSet<>();

Di default,

  • La capacità dell'insieme hash linkato sarà 16

  • Il fattore di carico sarà 0.75

Creare LinkedHashSet da altri insiemi

Ecco come possiamo creare un insieme hash linkato che contiene tutti gli elementi di altri insiemi.

import java.util.LinkedHashSet;
import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        //Creare arrayList di numeri pari
        ArrayList<Integer> evenNumbers = new ArrayList<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("ArrayList: " + evenNumbers);
        //Creare LinkedHashSet da ArrayList
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>(evenNumbers);
        System.out.println("LinkedHashSet: " + numbers);
    }
}

Risultato di output

ArrayList: [2, 4]
LinkedHashSet: [2, 4]

Metodi di LinkedHashSet

La classe LinkedHashSet fornisce vari metodi per eseguire diverse operazioni sull'insieme hash della coda.

Inserire l'elemento nel LinkedHashSet

  • add() - Inserisce l'elemento specificato nell'insieme hash della coda

  • addAll() - Inserisce tutti gli elementi dell'insieme specificato nell'insieme hash della coda

Ad esempio,

import java.util.LinkedHashSet;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> evenNumber = new LinkedHashSet<>();
        //Utilizzare il metodo add()
        evenNumber.add(2);
        evenNumber.add(4);
        evenNumber.add(6);
        System.out.println("LinkedHashSet: " + evenNumber);
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        
        //Utilizzare il metodo addAll()
        numbers.addAll(evenNumber);
        numbers.add(5);
        System.out.println("Nuovo LinkedHashSet: " + numbers);
    }
}

Risultato di output

LinkedHashSet: [2, 4, 6]
Nuovo LinkedHashSet: [2, 4, 6, 5]

Accedere agli elementi di LinkedHashSet

Per accedere agli elementi dell'insieme hash della coda, possiamo utilizzare il metodo iterator(). Per utilizzare questo metodo, dobbiamo importare il pacchetto java.util.Iterator. Ad esempio,

import java.util.LinkedHashSet;
import java.util.Iterator;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("LinkedHashSet: " + numbers);
        //Chiamata al metodo iterator()
        Iterator<Integer> iterate = numbers.iterator();
        System.out.print("Utilizza LinkedHashSet con Iterator: ");
        //Accedi agli elementi
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

Risultato di output

LinkedHashSet: [2, 5, 6]
Utilizza LinkedHashSet con Iterator: 2, 5, 6,

Attenzione:

  • hasNext() restituisce true se nella hash table collegata esiste un elemento successivo

  • next() restituisce l'elemento successivo nella hash table collegata

Elimina l'elemento dal HashSet

  • remove() - Elimina l'elemento specificato dalla hash table della coda

  • removeAll() - Elimina tutti gli elementi dalla hash table della coda

Ad esempio,

import java.util.LinkedHashSet;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("LinkedHashSet: " + numbers);
        //Utilizza il metodo remove()
        boolean value1 = numbers.remove(5);
        System.out.println("Eliminato il numero 5? " + value1);
        boolean value2 = numbers.removeAll(numbers);
        System.out.println("Sono stati eliminati tutti gli elementi? " + value2);
    }
}

Risultato di output

LinkedHashSet: [2, 5, 6]
Eliminato il numero 5? true
Sono stati eliminati tutti gli elementi? true

Metodi di operazione LinkedHashSet

Le varie metodologie della classe LinkedHashSet possono essere utilizzate per eseguire vari operazioni di Set.

Intersezione

Eseguiamo l'intersezione tra due insiemi utilizzando il metodo addAll(). Ad esempio,

import java.util.LinkedHashSet;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("LinkedHashSet1: " + evenNumbers);
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(1);
        numbers.add(3);
        System.out.println("LinkedHashSet2: " + numbers);
        //Unione tra due insiemi
        numbers.addAll(evenNumbers);
        System.out.println("Unione: " + numbers);
    }
}

Risultato di output

LinkedHashSet1: [2, 4]
LinkedHashSet2: [1, 3]
Unione: [1, 3, 2, 4]

Intersezione

Per eseguire l'intersezione tra due insiemi, possiamo utilizzare il metodo retainAll(). Ad esempio

import java.util.LinkedHashSet;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        System.out.println("LinkedHashSet1: " + primeNumbers);
        LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("LinkedHashSet2: " + evenNumbers);
        //Intersezione degli insiemi
        evenNumbers.retainAll(primeNumbers);
        System.out.println("Intersezione degli insiemi: " + evenNumbers);
    }
}

Risultato di output

LinkedHashSet1: [2, 3]
LinkedHashSet2: [2, 4]
Intersezione degli insiemi: [2]

Differenza

Per calcolare la differenza tra due insiemi, possiamo utilizzare il metodo removeAll(). Ad esempio,

import java.util.LinkedHashSet;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        primeNumbers.add(5);
        System.out.println("LinkedHashSet1: " + primeNumbers);
        LinkedHashSet<Integer> oddNumbers = new LinkedHashSet<>();
        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);
        System.out.println("LinkedHashSet2: " + oddNumbers);
        //Differenza tra LinkedHashSet1 e LinkedHashSet2
        primeNumbers.removeAll(oddNumbers);
        System.out.println("Differenza: " + primeNumbers);
    }
}

Risultato di output

LinkedHashSet1: [2, 3, 5]
LinkedHashSet2: [1, 3, 5]
Differenza: [2]

sottoinsieme

Per controllare se un insieme è un sottoinsieme di un altro insieme, possiamo utilizzare il metodo containsAll(). Ad esempio,

import java.util.LinkedHashSet;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        System.out.println("LinkedHashSet1: " + numbers);
        LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        System.out.println("LinkedHashSet2: " + primeNumbers);
        //Controllare se primeNumbers è un sottoinsieme di numbers
        boolean result = numbers.containsAll(primeNumbers);
        System.out.println("LinkedHashSet2 è un sottoinsieme di LinkedHashSet1? " + result);
    }
}

Risultato di output

LinkedHashSet1: [1, 2, 3, 4]
LinkedHashSet2: [2, 3]
LinkedHashSet2 è un sottoinsieme di LinkedHashSet1? true

Altri metodi di LinkedHashSet

MetodoDescrizione
clone()Creare una copia del LinkedHashSet
contains()Cercare l'elemento specificato nel LinkedHashSet e restituire il risultato booleano
isEmpty()Controllare se il LinkedHashSet è vuoto
size()Restituire la dimensione del LinkedHashSet
clear()Eliminare tutti gli elementi dal LinkedHashSet

La differenza tra LinkedHashSet e HashSet

LinkedHashSet e HashSet entrambi implementano l'interfaccia Set. Ma ci sono alcune differenze tra loro.

  • LinkedHashSet mantiene internamente una coda. Pertanto, mantiene l'ordine di inserimento dei suoi elementi.

  • LinkedHashSet richiede più spazio di archiviazione rispetto a HashSet. Questo è perché LinkedHashSet mantiene internamente una coda.

  • La performance di LinkedHashSet è più lenta rispetto a HashSet. Questo è perché esiste una coda in LinkedHashSet.

Differenze tra LinkedHashSet e TreeSet

Di seguito sono riportate le principali differenze tra LinkedHashSet e TreeSet:

  • La classe TreeSet implementa l'interfaccia SortedSet. Ecco perché gli elementi nella raccolta ad albero sono ordinati. Tuttavia, la classe LinkedHashSet mantiene solo l'ordine di inserimento dei suoi elementi.

  • TreeSet è generalmente più lento di LinkedHashSet. Questo è perché ogni volta che si aggiunge un elemento a TreeSet, deve eseguire l'operazione di ordinamento.

  • LinkedHashSet permette l'inserimento di valori nulli. Tuttavia, non possiamo inserire valori nulli in TreeSet.