Java TreeMap

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

Essa ereditaInterfaccia NavigableMap.

Creare un TreeMap

Per creare TreeMap, dobbiamo prima importare il pacchetto java.util.TreeMap. Dopo aver importato il pacchetto, possiamo utilizzare i seguenti metodi per creare TreeMap in Java.

TreeMap<Key, Value> numbers = new TreeMap<>();

Nel codice sopra, abbiamo creato una TreeMap chiamata numbers senza alcun parametro. In questo esempio, gli elementi della TreeMap sono ordinati in modo naturale (in ordine crescente).

Ma possiamo personalizzare l'ordinamento degli elementi utilizzando l'interfaccia Comparator. Lo impareremo nella parte successiva di questa guida.

Qui,

• Key - L'identificatore unico utilizzato per associare ogni elemento (valore) nel map

• Value - L'elemento associato alla chiave nel map

Metodi di TreeMap

La classe TreeMap fornisce vari metodi che ci permettono di eseguire operazioni sulla mappatura.

Inserimento degli elementi in TreeMap

• put() - Inserisce la mappatura chiave/valore specificata nel map

• putAll() - Inserisce tutti gli elementi della mappatura specificata in questo map

• putIfAbsent() - Se la mappatura non contiene la chiave specificata, inserisce la mappatura chiave/valore specificata nel map

Ad esempio,

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

Risultato di output

TreeMap degli numeri pari: {Four=4, Six=6, Two=2}
Numeri di TreeMap: {Four=4, One=1, Six=6, Two=2}

Accesso agli elementi di TreeMap

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

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

• keySet() - restituisce l'insieme di tutte le chiavi del TreeMap

• values() - restituisce l'insieme di tutti i valori del TreeMap

Ad esempio,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One", 1);
　　　　　　　　numbers.put("Two", 2);
　　　　　　　　numbers.put("Three", 3);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　// Uso di entrySet()
　　　　　　　　System.out.println("Mappa Chiave/Valore: " + numbers.entrySet());
　　　　　　　　// Uso di keySet()
　　　　　　　　System.out.println("Chiavi: " + numbers.keySet());
　　　　　　　　// Uso di values()
　　　　　　　　System.out.println("Valori: " + numbers.values());
　　　　}
}

Risultato di output

TreeMap: {One=1, Three=3, Two=2}
Mappa Chiave/Valore: [One=1, Three=3, Two=2]
Chiavi: [One, Three, Two]
Valori: [1, 3, 2]

2. Uso di 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 di default specificato.

Ad esempio,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One", 1);
　　　　　　　　numbers.put("Two", 2);
　　　　　　　　numbers.put("Three", 3);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　// Uso di get()
　　　　　　　　int value1 = numbers.get("Three");
　　　　　　　　System.out.println("Uso di get(): " + value1);
　　　　　　　　// Uso di getOrDefault()
　　　　　　　　int value2 = numbers.getOrDefault("Five", 5);
　　　　　　　　System.out.println("Uso di getOrDefault(): " + value2);
　　　　}
}

Risultato di output

TreeMap: {One=1, Three=3, Two=2}
Uso di get(): 3
Uso di getOrDefault(): 5

rimozione dell'elemento TeeMap

• remove(key) - restituisce e rimuove l'elemento associato alla chiave specificata dal TreeMap

• remove(key, value) - rimuove l'elemento dalla mappa solo se la chiave e il valore specificati sono associati, e restituisce un valore booleano

Ad esempio,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One", 1);
　　　　　　　　numbers.put("Two", 2);
　　　　　　　　numbers.put("Three", 3);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　// metodo di rimozione con singolo parametro
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("Il valore rimosso: " + value);
　　　　　　　　// Metodo di rimozione con due parametri
　　　　　　　　boolean result = numbers.remove("Three", 3);
　　　　　　　　System.out.println("L'elemento {Three=3} è stato rimosso? " + result);
　　　　　　　　System.out.println("TreeMap aggiornato: " + numbers);
　　　　}
}

Risultato di output

TreeMap: {One=1, Three=3, Two=2}
Il valore rimosso = 2
L'elemento {Three=3} è stato rimosso? True
TreeMap aggiornato: {One=1}

Sostituisci gli elementi TreeMap

• replace(key, value) - Sostituisce il valore associato alla chiave specificata con un nuovo valore key

• replace(key, old, new) - Sostituisce il valore vecchio con un nuovo valore solo se il vecchio valore è associato alla chiave specificata

• replaceAll(function) - Sostituisce ogni valore del map con il risultato specificato function

Ad esempio,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　numbers.put("Third", 3);
　　　　　　　　System.out.println("TreeMap originale: " + numbers);
　　　　　　　　// Utilizzo di replace()
　　　　　　　　numbers.replace("Second", 22);
　　　　　　　　numbers.replace("Third", 3, 33);
　　　　　　　　System.out.println("TreeMap utilizza il metodo replace(): " + numbers);
　　　　　　　　// Utilizzo di replaceAll()
　　　　　　　　numbers.replaceAll((key, oldValue) -> oldValue + 2);
　　　　　　　　System.out.println("TreeMap utilizza il metodo replaceAll(): " + numbers);
　　　　}
}

Risultato di output

TreeMap originale: {First=1, Second=2, Third=3}
TreeMap utilizza il metodo replace(): {First=1, Second=22, Third=33}
TreeMap utilizza il metodo replaceAll(): {First=3, Second=24, Third=35}

Nella seguente programma, presta attenzione alla seguente istruzione

numbers.replaceAll((key, oldValue) -> oldValue + 2);

Qui, abbiamo passato unespressione lambdacome parametro.

Il metodo replaceAll() accede a tutte le voci del map. Poi, sostituisce tutti gli elementi con un nuovo valore (ritornato dall'espressione lambda).

Metodi di navigazione

Poiché la classe TreeMap ha implementato NavigableMap, fornisce vari metodi di navigazione sugli elementi di TreeMap.

1. Metodi del primo e dell'ultimo

• firstKey() - Restituisce la prima chiave della mappa

• firstEntry() - Restituisce la mappatura della chiave/valore della prima chiave della mappa

• lastKey() - Restituisce l'ultima chiave della mappa

• lastEntry() - Restituisce la mappatura della chiave/valore dell'ultima chiave della mappa

Ad esempio,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　numbers.put("Third", 3);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　// Utilizzo del metodo firstKey()
　　　　　　　　String firstKey = numbers.firstKey();
　　　　　　　　System.out.println("La prima chiave: " + firstKey);
　　　　　　　　// Utilizzo del metodo lastKey()
　　　　　　　　String lastKey = numbers.lastKey();
　　　　　　　　System.out.println("L'ultima chiave: " + lastKey);
　　　　　　　　// Utilizzo del metodo firstEntry()
　　　　　　　　System.out.println("Il primo elemento: " + numbers.firstEntry());
　　　　　　　　// Utilizzo del metodo lastEntry()
　　　　　　　　System.out.println("L'ultimo elemento: " + numbers.lastEntry());
　　　　}
}

Risultato di output

TreeMap: {First=1, Second=2, Third=3}
La prima chiave: First
L'ultima chiave: Third
Il primo elemento: First=1
L'ultimo elemento: Third=3

2. Metodi di limite superiore, inferiore e di limite

• HigherKey() - Restituisce la chiave minima tra tutte quelle superiori alla chiave specificata.

• HigherEntry() - Restituisce l'entry associata alla chiave minima tra tutte quelle superiori alla chiave specificata.

• lowerKey() - Restituisce la chiave massima tra tutte quelle inferiori alla chiave specificata.

• lowerEntry() - Restituisce l'entry associata alla chiave massima tra quelle inferiori alla chiave specificata.

• ceilingKey() - Restituisce la chiave minima tra quelle superiori alla chiave specificata. Se la mappa contiene la chiave passata come parametro, restituisce quella chiave.

• ceilingEntry() - Restituisce l'entry associata alla chiave minima tra quelle superiori alla chiave specificata. Se la mappa contiene un entry associata alla chiave passata come argomento, restituisce l'entry associata a quella chiave.

• floorKey() - Restituisce la chiave massima tra quelle inferiori alla chiave specificata. Se esiste una chiave passata come parametro, restituisce quella chiave.

• floorEntry() - Restituisce l'entry relativa alla chiave più grande minore rispetto a quella specificata. Se esiste una chiave passata come parametro, restituisce quella chiave.

Ad esempio,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 5);
　　　　　　　　numbers.put("Third", 4);
　　　　　　　　numbers.put("Fourth", 6);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　// Utilizzando higher()
　　　　　　　　System.out.println("Utilizzando higherKey(): " + numbers.higherKey("Fourth"));
　　　　　　　　System.out.println("Utilizzando higherEntry(): " + numbers.higherEntry("Fourth"));
　　　　　　　　// Utilizzando lower()
　　　　　　　　System.out.println("\nUtilizzando lowerKey(): " + numbers.lowerKey("Fourth"));
　　　　　　　　System.out.println("Utilizzando lowerEntry(): " + numbers.lowerEntry("Fourth"));
　　　　　　　　// Utilizzando ceiling()
　　　　　　　　System.out.println("\nUtilizzando ceilingKey(): " + numbers.ceilingKey("Fourth"));
　　　　　　　　System.out.println("Utilizzando ceilingEntry(): " + numbers.ceilingEntry("Fourth"));
　　　　　　　　// Utilizzando floor()
　　　　　　　　System.out.println("\nUtilizzando floorKey(): " + numbers.floorKey("Fourth"));
　　　　　　　　System.out.println("Utilizzando floorEntry(): " + numbers.floorEntry("Fourth"));
　　　　}
}

Risultato di output

TreeMap: {First=1, Fourth=6, Second=5, Third=4}
Utilizzando higherKey(): Second
Utilizzando higherEntry(): Second=5
Utilizzando lowerKey(): First
Utilizzando lowerEntry(): First=1
Utilizzando ceilingKey(): Fourth
Utilizzando ceilingEntry(): Fourth=6
Utilizzando floorkey(): Fourth
Utilizzo di floorEntry(): Fourth=6

3. Metodi pollFirstEntry() e pollLastEntry()

• pollFirstEntry() - Restituisce ed elimina l'elemento associato alla prima chiave nella mappa.

• pollLastEntry() - Restituisce ed elimina l'elemento associato all'ultima chiave nella mappa.

Ad esempio,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　numbers.put("Third", 3);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　// Utilizzo del metodo pollFirstEntry()
　　　　　　　　System.out.println("Utilizzo di pollFirstEntry(): " + numbers.pollFirstEntry());
　　　　　　　　// Utilizzo del metodo pollLastEntry()
　　　　　　　　System.out.println("Utilizzo di pollLastEntry(): " + numbers.pollLastEntry());
　　　　　　　　System.out.println("TreeMap aggiornato: " + numbers);
　　　　}
}

Risultato di output

TreeMap: {First=1, Second=2, Third=3}
Utilizzo di pollFirstEntry(): First=1
Utilizzo di pollLastEntry(): Third=3
TreeMap aggiornato: {Second=2}

4. Metodi headMap(), tailMap() e subMap()

headMap(key,booleanValue)

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

Se il valore booleano è true, il metodo include anche la coppia di chiave/valore specificata per la chiave.

Ad esempio,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　numbers.put("Third", 3);
　　　　　　　　numbers.put("Fourth", 4);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　System.out.println("\nUtilizzo del metodo headMap():");
　　　　　　　　// headMap() utilizza il valore booleano predefinito come false
　　　　　　　　System.out.println("Non è stato specificato il valore booleano: " + numbers.headMap("Fourth"));
　　　　　　　　// headMap() utilizza il valore booleano specificato come true
　　　　　　　　System.out.println("Specificare il valore booleano come true: " + numbers.headMap("Fourth", true));
　　　　}
}

Risultato di output

TreeMap: {First=1, Fourth=4, Second=2, Third=3}
Utilizzo del metodo headMap():　
Non è stato specificato il valore booleano: {First=1}
Specificare il valore booleano true: {First=1, Fourth=4}

tailMap(key, booleanValue)

Il metodo tailMap() restituisce tutti i coppia di chiave/valore della mappa a partire dalla chiave specificata (passata come parametro).

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

Se booleanValue è false, questo metodo non include il coppia di chiave/valore specificata.

Ad esempio,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　numbers.put("Third", 3);
　　　　　　　　numbers.put("Fourth", 4);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　System.out.println("\nUtilizzo del metodo tailMap(): ");
　　　　　　　　// Utilizzo del valore predefinito true per il booleanValue del metodo tailMap()
　　　　　　　　System.out.println("booleanValue utilizza il valore predefinito true: " + numbers.tailMap("Second"));
　　　　　　　　// Utilizzo del valore specificato false per il booleanValue del metodo tailMap()
　　　　　　　　System.out.println("booleanValue utilizza il valore specificato false: " + numbers.tailMap("Second", false));
　　　　}
}

Risultato di output

TreeMap: {First=1, Fourth=4, Second=2, Third=3}
Utilizzo del metodo tailMap():
booleanValue utilizza il valore predefinito true: {Second=2, Third=3}
booleanValue utilizza il valore specificato false: {Third=3}

subMap(k1, bV1, k2, bV2)

Il metodo subMap() restituisce tutti gli elementi associati alle chiavi tra k1 e k2, inclusi gli elementi associati a k1.

bV1 e bV2 sono parametri booleani opzionali. Il valore predefinito di bV1 è true, mentre quello di bV2 è false.

Se bV1 è false, questo metodo restituisce tutti gli elementi associati alle chiavi tra k1 e k2, ma non inclusi gli elementi associati a k1.

Se bV2 è true, questo metodo restituisce tutti gli elementi associati alle chiavi tra k1 e k2, inclusi gli elementi associati a k2.

Ad esempio,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　numbers.put("Third", 3);
　　　　　　　　numbers.put("Fourth", 4);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　System.out.println("\nUtilizzo del metodo subMap(): ");
　　　　　　　　// Utilizzo del metodo tailMap() con valore booleano predefinito
　　　　　　　　System.out.println("Utilizzo del valore booleano predefinito: " + numbers.subMap("Fourth", "Third"));
　　　　　　　　// tailMap() specifica il valore booleano
　　　　　　　　System.out.println("Specifica il valore booleano: " + numbers.subMap("Fourth", false, "Third", true));
　　　　}
}

Risultato di output

TreeMap: {First=1, Fourth=2, Second=2, Third=3}
Usa il metodo subMap():
Usa il valore booleano predefinito: {Fourth=4, Second=2}
Specifica il valore booleano: {Second=2, Third=3}

Altri metodi TreeMap

Comparatore TreeMap

In tutti gli esempi precedenti, gli elementi del treemap sono ordinati in modo naturale (in ordine crescente). Ma possiamo anche definire l'ordine delle chiavi.

Per questo, dobbiamo creare la nostra classe comparatore basandoci sul modo in cui i chiavi vengono ordinati nel grafo ad albero. Ad esempio,

import java.util.TreeMap;
import java.util.Comparator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　// 使用自定义比较器创建treemap
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>(new CustomComparator());
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　numbers.put("Third", 3);
　　　　　　　　numbers.put("Fourth", 4);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　}
　　　　// 创建一个比较器类
　　　　public static class CustomComparator implements Comparator<String> {
　　　　　　　　@Override
　　　　　　　　public int compare(String number1, String number2) {
　　　　　　　　　　　　int value = number1.compareTo(number2);
　　　　　　　　　　　　// Gli elementi vengono ordinati in ordine inverso
　　　　　　　　　　　　if (value > 0) {
　　　　　　　　　　　　　　　　return -1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else if (value < 0) {
　　　　　　　　　　　　　　　　return 1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else {
　　　　　　　　　　　　　　　　return 0;
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

Risultato di output

TreeMap: {Third=3, Second=2, Fourth=4, First=1}

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

La classe CustomComparator implementa l'interfaccia Comparator.

Poi ricorda di sovrascrivere il metodo compare() in modo che gli elementi siano ordinati in ordine inverso.