Java TreeSet

In questo tutorial, impareremo grazie a esempi la classe Java TreeSet e le sue varie operazioni e metodi.

La classe TreeSet del Java Collection Framework fornisce le funzionalità della struttura dati ad albero.

EsaustaInterfaccia NavigableSet.

Creare un TreeSet

Per creare un TreeSet, dobbiamo prima importare il pacchetto java.util.TreeSet.

Dopo aver importato il pacchetto, ecco come creare un TreeSet in Java.

TreeSet<Integer> numbers = new TreeSet<>();

Ecco come abbiamo creato un TreeSet senza parametri. In questo esempio, gli elementi del TreeSet sono ordinati in modo naturale (ordinato in aumento).

Ma possiamo utilizzare l'interfaccia Comparator per personalizzare l'ordinamento degli elementi. Lo impareremo nella parte successiva di questo tutorial.

Metodi della TreeSet

La classe TreeSet fornisce vari metodi che ci permettono di eseguire varie operazioni sulle collezioni.

Inserimento degli elementi nella TreeSet

• add() - Inserisce l'elemento specificato nel set

• addAll() - Inserisce tutti gli elementi di un set specificato nel set

Ad esempio:

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> evenNumbers = new TreeSet<>();
　　　　　　　　// Utilizzo del metodo add()
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　evenNumbers.add(6);
　　　　　　　　System.out.println("TreeSet: " + evenNumbers);
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　// Utilizzo del metodo addAll()
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("Nuovo TreeSet: " + numbers);
　　　　}
}

Risultato di output

TreeSet: [2, 4, 6]
Nuova TreeSet: [1, 2, 4, 6]

Accesso agli elementi della TreeSet

Per accedere agli elementi della TreeSet, possiamo utilizzare il metodo iterator(). Per utilizzare questo metodo, dobbiamo importare il pacchetto java.util.Iterator. Ad esempio,

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

Risultato di output

TreeSet: [2, 5, 6]
TreeSet utilizza l'iteratore: 2, 5, 6,

Eliminazione degli elementi

• remove() - Elimina l'elemento specificato dal set

• removeAll() - Elimina tutti gli elementi dal set

Ad esempio:

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

Risultato di output

TreeSet: [2, 5, 6]
È stato eliminato il numero 5? true
Sono stati eliminati tutti gli elementi? true

Metodi di navigazione

Poiché la classe TreeSet ha implementato NavigableSet, fornisce vari metodi per navigare gli elementi del set.

1. Metodi first() e last()

• first() - Restituisce il primo elemento della collezione

• last() - Restituisce l'ultimo elemento della collezione

Ad esempio:

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet:　"　+　numbers);
　　　　　　　　// Utilizzo del metodo first()
　　　　　　　　int first = numbers.first();
　　　　　　　　System.out.println("Primo numero: " + first);
　　　　　　　　// Utilizzo del metodo last()
　　　　　　　　int last = numbers.last();
　　　　　　　　System.out.println("Ultimo numero: " + last);
　　　　}
}

Risultato di output

TreeSet: [2, 5, 6]
Primo numero: 2
Ultimo numero: 6

2. Metodi ceiling(), floor(), higher() e lower()

• Higher(element) - Restituisce l'elemento più piccolo maggiore dell'elemento specificato (element).

• lower(element) - Restituisce l'elemento più grande minore dell'elemento specificato (element).

• ceiling(element) - Restituisce l'elemento più piccolo maggiore dell'elemento specificato (element). Se l'elemento specificato esiste nel set, restituisce l'elemento specificato come parametro.

• floor(element) - Restituisce l'elemento più grande minore dell'elemento specificato (element). Se l'elemento specificato esiste nel set, restituisce l'elemento specificato come parametro.

Ad esempio:

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet:　"　+　numbers);
　　　　　　　　// Utilizzo di higher()
　　　　　　　　System.out.println("Utilizzo di higher: " + numbers.higher(4));
　　　　　　　　// Utilizzo di lower()
　　　　　　　　System.out.println("Utilizzo di lower: " + numbers.lower(4));
　　　　　　　　// Utilizzo di ceiling()
　　　　　　　　System.out.println("Utilizzo di ceiling: " + numbers.ceiling(4));
　　　　　　　　// Utilizzo di floor()
　　　　　　　　System.out.println("Utilizzo di floor: " + numbers.floor(3));
　　　　}
}

Risultato di output

TreeSet:　[2,　4,　5,　6]
Utilizzo di higher: 5
Utilizzo di lower: 2
Utilizzo di ceiling: 4
Utilizzo di floor: 2

3. Metodi pollfirst() e pollLast()

• pollFirst() - Restituisce e elimina il primo elemento dalla collezione

• pollLast() - Restituisce e elimina l'ultimo elemento dalla collezione

Ad esempio:

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet:　"　+　numbers);
　　　　　　　　// Utilizzo di pollFirst()
　　　　　　　　System.out.println("Elimina il primo elemento: " + numbers.pollFirst());
　　　　　　　　// Utilizzo di pollLast()
　　　　　　　　System.out.println("Elimina l'ultimo elemento: " + numbers.pollLast());
　　　　　　　　System.out.println("Nuovo TreeSet: " + numbers);
　　　　}
}

Risultato di output

TreeSet:　[2,　4,　5,　6]
Elimina il primo elemento: 2
Elimina l'ultimo elemento: 6
Nuovo TreeSet: [4, 5]

4. Metodi headSet(), tailSet() e subSet()

headSet(element,booleanValue)

Il metodo headSet() restituisce tutti gli elementi dell'albero di insieme precedenti all'elemento specificato (passato come parametro).

Il parametro booleanValue è opzionale. Il valore predefinito è false.

Se il valore di booleanValue è true, il metodo restituirà tutti gli elementi precedenti all'elemento specificato, inclusi l'elemento specificato.

Ad esempio:

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet:　"　+　numbers);
　　　　　　　　// Utilizzo di headSet() con il valore booleano predefinito
　　　　　　　　System.out.println("Utilizza headSet senza valore booleano: " + numbers.headSet(5));
　　　　　　　　// Utilizzo di headSet() con il valore booleano specificato
　　　　　　　　System.out.println("Utilizza headSet con il valore booleano: " + numbers.headSet(5, true));
　　　　}
}

Risultato di output

TreeSet:　[2,　4,　5,　6]
Utilizza headSet senza valore booleano: [2, 4]
Utilizza headSet con il valore booleano: [2, 4, 5]

tailSet(element,booleanValue)

Il metodo tailSet() restituisce tutti gli elementi dell'albero di insieme successivi all'elemento specificato (passato come parametro).

Il parametro booleanValue è opzionale. Il valore predefinito è true.

Se false viene passato come a al booleanValue, il metodo restituirà tutti gli elementi specificati, element, ma non incluso l'elemento specificato.

Ad esempio:

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet:　"　+　numbers);
　　　　　　　　// Utilizzo di tailSet() con il valore booleano predefinito
　　　　　　　　System.out.println("tailSet() utilizza il valore booleano predefinito: " + numbers.tailSet(4));
　　　　　　　　//　utilizzo di tailSet() con valore booleano specificato
　　　　　　　　System.out.println("tailSet() con valore booleano:　"　+　numbers.tailSet(4,　false));
　　　　}
}

Risultato di output

TreeSet:　[2,　4,　5,　6]
Utilizzo di tailSet() con valore booleano predefinito:　[4,　5,　6]
tailSet() con valore booleano:　[5,　6]

subSet(e1,bv1,e2,bv2)

Il metodo subSet() restituisce tutti gli elementi tra e1 e e2, inclusi e1.

bv1 e bv2 sono parametri opzionali. 　Il valore predefinito di bv1 è true, mentre il valore predefinito di bv2 è false.

Se false viene passato come bv1, il metodo restituisce tutti gli elementi tra e1 e e2, ma non inclusi e1.

Se true viene passato come bv2, il metodo restituisce tutti gli elementi tra e1 e e2, inclusi e1.

Ad esempio:

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet:　"　+　numbers);
　　　　　　　　//　utilizzo di subSet() con valore booleano predefinito
　　　　　　　　System.out.println("subSet() utilizza il valore booleano predefinito:　"　+　numbers.subSet(4,　6));
　　　　　　　　//　utilizzo di subSet() con valore booleano specificato
　　　　　　　　System.out.println("subSet() utilizza il valore booleano specificato:　"　+　numbers.subSet(4,　false,　6,　true));
　　　　}
}

Risultato di output

TreeSet:　[2,　4,　5,　6]
subSet() utilizza il valore booleano predefinito:　[4,　5]
subSet() utilizza il valore booleano specificato:　[5,　6]

Metodi di operazione Set

I metodi della classe TreeSet possono essere utilizzati per eseguire vari operazioni sugli insiemi.

Unione degli insiemi

Per eseguire l'unione tra due insiemi, utilizziamo il metodo addAll(). Ad esempio:

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> evenNumbers = new TreeSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("TreeSet1: " + evenNumbers);
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("TreeSet2: " + numbers);
　　　　　　　　//　unione degli insiemi
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("Unione　is:　"　+　numbers);
　　　　}
}

Risultato di output

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
Unione:　[1,　2,　3,　4]

Intersezione degli insiemi

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

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> evenNumbers = new TreeSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("TreeSet1: " + evenNumbers);
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("TreeSet2: " + numbers);
　　　　　　　　//　due交集
　　　　　　　　numbers.retainAll(evenNumbers);
　　　　　　　　System.out.println("Intersezione degli insiemi: " + numbers);
　　　　}
}

Risultato di output

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
Intersezione degli insiemi: [2]

Differenza degli insiemi

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

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> evenNumbers = new TreeSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("TreeSet1: " + evenNumbers);
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　numbers.add(4);
　　　　　　　　System.out.println("TreeSet2: " + numbers);
　　　　　　　　//Differenza degli insiemi
　　　　　　　　numbers.removeAll(evenNumbers);
　　　　　　　　System.out.println("Differenza: " + numbers);
　　　　}
}

Risultato di output

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3, 4]
Differenza: [1, 3]

Sottoinsieme dell'insieme

Per verificare se un insieme è un sottoinsieme di un altro insieme, utilizziamo il metodo containsAll(). Ad esempio,

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

Risultato di output

TreeSet1: [1, 2, 3, 4]
TreeSet2: [2, 3]
TreeSet2 è un sottoinsieme di TreeSet1? True

Altri metodi di TreeSet

TreeSet Vs. HashSet

TreeSet e HashSet implementano entrambi l'interfaccia Set. Tuttavia, ci sono alcune differenze tra loro.

• Diversamente da HashSet, gli elementi in TreeSet sono memorizzati in un certo ordine. Questo è perché TreeSet implementa anche l'interfaccia SortedSet.

• TreeSet offre alcuni metodi facili da navigare. Ad esempio first(), last(), headSet(), tailSet() e così via. Questo è perché TreeSet implementa anche l'interfaccia NavigableSet.

• Per operazioni di base come aggiungere, rimuovere, contenere e dimensione, HashSet è più veloce di TreeSet.

Comparatore TreeSet

In tutti gli esempi precedenti, gli elementi della TreeSet sono ordinati in modo naturale. Ma possiamo anche definire l'ordine degli elementi.

Per questo, dobbiamo creare la nostra classe comparator, basata sull'ordinamento degli elementi nel set di alberi. Ad esempio

import java.util.TreeSet;
import java.util.Comparator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//使用自定义比较器创建TreeSet
　　　　　　　　TreeSet<String> animals = new TreeSet<>(new CustomComparator());
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Zebra");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("TreeSet: " + animals);
　　　　}
　　　　//创建一个比较器类
　　　　public static class CustomComparator implements Comparator<String> {
　　　　　　　　@Override
　　　　　　　　public int compare(String animal1, String animal2) {
　　　　　　　　　　　　int value = animal1.compareTo(animal2);
　　　　　　　　　　　　// Gli elementi vengono ordinati in senso inverso
　　　　　　　　　　　　if (value > 0) {
　　　　　　　　　　　　　　　　return -1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else if (value < 0) {
　　　　　　　　　　　　　　　　return 1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else {
　　　　　　　　　　　　　　　　return 0;
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

Risultato di output

TreeSet: [Zebra, Cavallo, Cane, Gatto]

Nell'esempio sopra, abbiamo creato un TreeSet, passando la classe CustomComparator come parametro.

La classe CustomComparator implements l'interfaccia Comparator.

Quindi, abbiamo ricreato il metodo compare(). Ora, questo metodo ordinerà gli elementi in senso inverso.