Java TreeMap

En este tutorial, aprenderemos con ejemplos la clase TreeMap de Java y sus operaciones.

Hereda deInterfaz NavigableMap.

Crear un TreeMap

Para crear TreeMap, primero debemos importar el paquete java.util.TreeMap. Después de importar el paquete, podemos crear TreeMap en Java utilizando el siguiente método.

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

En el código anterior, creamos un TreeMap llamado numbers sin parámetros. En este ejemplo, los elementos del TreeMap están ordenados de manera natural (ascendente).

pero, podemos personalizar el orden de los elementos utilizando el interfaz Comparator. Lo aprenderemos en la parte posterior de este tutorial.

aquí,

• Clave - usado como identificador único para asociar cada elemento (valor) en el mapa

• Valor - los elementos asociados con la clave en el mapa

métodos de TreeMap

la clase TreeMap proporciona varios métodos que permiten realizar operaciones en el mapeo.

insertar el elemento en TreeMap

• put() - insertar la clave especificada/insertar el mapeo de valores (entradas) en el mapeo

• putAll() - insertar todos los elementos de la mapeo especificada en este mapeo

• putIfAbsent() - si el mapeo no contiene la clave especificada, insertar la clave especificada/insertar el mapeo de valores en el mapa

por ejemplo,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//creando TreeMap de números pares
　　　　　　　　TreeMap<String, Integer> evenNumbers = new TreeMap<>();
　　　　　　　　//　usar put()
　　　　　　　　evenNumbers.put("Two",　2);
　　　　　　　　evenNumbers.put("Four",　4);
　　　　　　　　//　usar putIfAbsent()
　　　　　　　　evenNumbers.putIfAbsent("Six",　6);
　　　　　　　　System.out.println("el TreeMap de números pares: "　+　evenNumbers);
　　　　　　　　//Creando TreeMap de números
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　//　usar putAll()
　　　　　　　　numbers.putAll(evenNumbers);
　　　　　　　　System.out.println("los números de TreeMap: "　+　numbers);
　　　　}
}

Resultado de salida

el TreeMap de números pares: {Four=4, Six=6, Two=2}
los números de TreeMap: {Four=4, One=1, Six=6, Two=2}

acceder a los elementos de TreeMap

1.usar entrySet(), keySet() y values()

• entrySet() - devolver todas las claves de TreeMap/colección de mapeos (entradas) de valores

• keySet() - devolver la colección de todas las claves de TreeMap

• values() - devolver la colección de todos los grafos de TreeMap

por ejemplo,

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);
　　　　　　　　//　usar entrySet()
　　　　　　　　System.out.println("Key"/Mapeo de valores: "　+　numbers.entrySet());
　　　　　　　　//　usar keySet()
　　　　　　　　System.out.println("Claves: "　+　numbers.keySet());
　　　　　　　　//　usar values()
　　　　　　　　System.out.println("Valores: ")　+　numbers.values());
　　　　}
}

Resultado de salida

TreeMap: {One=1, Three=3, Two=2}
Clave/Mapeo de valores: [One=1, Three=3, Two=2]
Claves: [One, Three, Two]
Valores: [1,　3,　2]

2.usar get() y getOrDefault()

• get() - devolver el valor asociado con la clave especificada. Si no se encuentra la clave, devuelve null.

• getOrDefault() - devolver el valor asociado con la clave especificada. Si no se encuentra la clave, devuelve el valor de predeterminado especificado.

por ejemplo,

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

Resultado de salida

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

eliminar elemento TreeMap

• remove(key) - devolver y eliminar la entrada asociada con la clave especificada del TreeMap

• remove(key, value) -eliminar entrada del mapeo solo si la clave especificada está asociada con el valor especificado, y devolver el valor booleano

por ejemplo,

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);
　　　　　　　　//método de eliminación con un solo parámetro
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("valor eliminado: ")　+　value);
　　　　　　　　//método de eliminación con dos parámetros
　　　　　　　　boolean result = numbers.remove("Three",　3);
　　　　　　　　System.out.println("entrada {Three=")3¿eliminado? "　+　result);
　　　　　　　　System.out.println("TreeMap actualizado: ");　+　numbers);
　　　　}
}

Resultado de salida

TreeMap: {One=1, Three=3, Two=2}
valor eliminado =　2
entrada {Three=3¿eliminado? True
TreeMap actualizado: {One=1}

reemplazar elemento TreeMap

• replace(key, value)-usar key nuevo para reemplazar el valor value de la mapeo especificado

• replace(key, old, new) -solo se reemplaza el valor antiguo con el nuevo valor cuando el valor antiguo ya está asociado con la clave especificada}}

• replaceAll(function) -reemplazar cada valor del mapa con el resultado especificado función

por ejemplo,

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("Original TreeMap: " );　+　numbers);
　　　　　　　　//　usar replace()
　　　　　　　　numbers.replace("Second",　22);
　　　　　　　　numbers.replace("Third",　3,　33);
　　　　　　　　System.out.println("TreeMap utiliza el método replace(): " );　+　numbers);
　　　　　　　　//　usar replaceAll()
　　　　　　　　numbers.replaceAll((key, oldValue)　-> oldValue　+　2);
　　　　　　　　System.out.println("TreeMap utiliza el método replaceAll(): " );　+　numbers);
　　　　}
}

Resultado de salida

Original TreeMap: {First=1,　Second=2, Third=3}
TreeMap utiliza el método replace(): {First=1,　Second=22, Third=33}
TreeMap utiliza el método replaceAll(): {First=3,　Second=24, Third=35}

En el programa anterior, preste atención a la sentencia

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

Aquí, pasamos unaexpresión lambdacomo parámetro.

El método replaceAll() accede a todos los elementos del mapa. Luego, reemplaza todos los elementos con nuevos valores (devueltos por la expresión lambda).

métodos de navegación

Porque la clase TreeMap implementa NavigableMap, por lo que proporciona varios métodos para navegar por los elementos de TreeMap.

1.primeros y últimos métodos

• firstKey() - devuelve la primera clave del mapa

• firstEntry() - devuelve la clave del primer valor del mapeo/mapeo de valores

• lastKey() - devuelve la última clave del mapa

• lastEntry() - devuelve la clave del último valor del mapeo/mapeo de valores

por ejemplo,

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);
　　　　　　　　//　usar el método firstKey()
　　　　　　　　String firstKey = numbers.firstKey();
　　　　　　　　System.out.println("La primera clave: " );　+　firstKey);
　　　　　　　　//　usar el método lastKey()
　　　　　　　　String lastKey = numbers.lastKey();
　　　　　　　　System.out.println("La última clave: " );　+　lastKey);
　　　　　　　　//　usar el método firstEntry()
　　　　　　　　System.out.println("El primer elemento: " );　+　numbers.firstEntry());
　　　　　　　　//　Usar el método the lastEntry()
　　　　　　　　System.out.println("El último elemento: ");　+　numbers.lastEntry());
　　　　}
}

Resultado de salida

TreeMap: {First=1,　Second=2, Third=3}
La primera clave: First
La última clave: Third
El primer elemento: First=1
El último elemento: Third=3

2.Métodos de límite superior e inferior, hacia arriba y hacia abajo

• HigherKey(); - Devuelve la clave más pequeña entre las claves mayores que la clave especificada.

• HigherEntry(); - Devuelve el elemento asociado con la clave más pequeña entre todas las claves mayores que la clave especificada.

• lowerKey(); - Devuelve la clave más grande entre todas las claves menores que la clave especificada.

• lowerEntry(); - Devuelve el elemento asociado con la clave más grande entre todas las claves menores que la clave especificada.

• ceilingKey(); - Devuelve la clave más pequeña entre las claves mayores que la clave especificada. Si en el mapeo existe una clave como parámetro, se devolverá esa clave.

• ceilingEntry(); - Devuelve el elemento asociado con la clave más pequeña entre las claves mayores que la clave especificada. Si en el mapeo existe un elemento asociado con la clave proporcionada como argumento, se devolverá el elemento asociado con esa clave.

• floorKey(); - Devuelve la clave más grande entre las claves menores que la clave especificada. Si existe una clave como parámetro, devolverá esa clave.

• floorEntry(); - Devuelve el elemento asociado con la clave más grande entre las claves menores que la clave especificada. Si existe una clave como parámetro, devolverá esa clave.

por ejemplo,

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);
　　　　　　　　//　Usar higher();
　　　　　　　　System.out.println("Usar higherKey(): ");　+　numbers.higherKey("Fourth"));
　　　　　　　　System.out.println("Usar higherEntry(): ");　+　numbers.higherEntry("Fourth"));
　　　　　　　　//　Usar lower();
　　　　　　　　System.out.println("\nUsar lowerKey(): ");　+　numbers.lowerKey("Fourth"));
　　　　　　　　System.out.println("Usar lowerEntry(): ");　+　numbers.lowerEntry("Fourth"));
　　　　　　　　//　Usar ceiling();
　　　　　　　　System.out.println("\nUsar ceilingKey(): ");　+　numbers.ceilingKey("Fourth"));
　　　　　　　　System.out.println("Usar ceilingEntry(): ");　+　numbers.ceilingEntry("Fourth"));
　　　　　　　　//　Utilizando floor()
　　　　　　　　System.out.println("\nUtilizando floorKey(): ");　+　numbers.floorKey("Fourth"));
　　　　　　　　System.out.println("Utilizando floorEntry(): ");　+　numbers.floorEntry("Fourth"));
　　　　}
}

Resultado de salida

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

3. métodos pollFirstEntry() y pollLastEntry()

• pollFirstEntry() - Devuelve y elimina la entrada asociada con la primera clave del mapeo

• pollLastEntry()　 -Devuelve y elimina la entrada asociada con la última clave del mapeo

por ejemplo,

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);
　　　　　　　　//Utilizando el método pollFirstEntry()
　　　　　　　　System.out.println("Utilizando pollFirstEntry(): ");　+　numbers.pollFirstEntry());
　　　　　　　　//　Utilizando el método pollLastEntry()
　　　　　　　　System.out.println("Utilizando pollLastEntry(): ");　+　numbers.pollLastEntry());
　　　　　　　　System.out.println("TreeMap actualizado: ");　+　numbers);
　　　　}
}

Resultado de salida

TreeMap: {First=1,　Second=2, Third=3}
Utilizando pollFirstEntry(): First=1
Utilizando pollLastEntry(): Third=3
TreeMap actualizado: {Second=2}

4. métodos headMap(), tailMap() y subMap()

headMap(key,booleanValue)

El parámetro booleanValue es opcional. El valor predeterminado es false.

Si el valor booleano es true, este método también incluye la clave especificada/pares de valores.

por ejemplo,

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("\nUtilizando el método headMap()");
　　　　　　　　//　headMap() usando el valor booleano predeterminado false
　　　　　　　　System.out.println("sin especificar el valor booleano: "　+　numbers.headMap("Fourth"));
　　　　　　　　//　headMap() usando el valor booleano especificado true
　　　　　　　　System.out.println("especificando el valor booleano true: "　+　numbers.headMap("Fourth", true));
　　　　}
}

Resultado de salida

TreeMap: {First=1,　Fourth=4,　Second=2, Third=3}
usando el método headMap():　
sin especificar el valor booleano: {First=1}
especificando el valor booleano true: {First=1,　Fourth=4}

tailMap(key,booleanValue)

el método tailMap() comienza a devolver todas las claves del árbol a partir de la clave especificada (pasada como parámetro)/pares de valores.

booleanValue es un parámetro opcional. El valor predeterminado es true.

Si el valor booleano es false, este método no contiene la clave especificada/pares de valores.

por ejemplo,

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("\nUsando el método tailMap(): ");
　　　　　　　　//　tailMap() valor booleano usando el valor predeterminado true
　　　　　　　　System.out.println("booleanValue usando el valor predeterminado true: "　+　numbers.tailMap("Second"));
　　　　　　　　//　tailMap() valor booleano usando el valor especificado false
　　　　　　　　System.out.println("booleanValue usando el valor especificado false: "　+　numbers.tailMap("Second", false));
　　　　}
}

Resultado de salida

TreeMap: {First=1,　Fourth=4,　Second=2, Third=3}
usando el método tailMap():
booleanValue usando el valor predeterminado true: {Second=2, Third=3}
booleanValue usando el valor especificado false: {Third=3}

subMap(k1,bV1,k2,bV2)

el método subMap() devuelve todas las entradas asociadas con k1y k2la asociación de claves entre1las entradas.

bV1y bV2es un parámetro booleano opcional. bV1su valor predeterminado es true, bV2su valor predeterminado es false.

si bV1si bV es false, este método devuelve todas las entradas asociadas con k1y k2la asociación de claves entre1las entradas.

si bV2si bV es true, este método devuelve todas las entradas asociadas con k1y k2la asociación de claves entre2las entradas.

por ejemplo,

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("\nUsar el método subMap():")
　　　　　　　　//　tailMap() valor booleano por defecto
　　　　　　　　System.out.println("Usar el valor booleano por defecto: ")　+　numbers.subMap("Fourth", "Third"));
　　　　　　　　//　tailMap() valor booleano especificado
　　　　　　　　System.out.println("Especificar el valor booleano: ")　+　numbers.subMap("Fourth", false, "Third", true));
　　　　}
}

Resultado de salida

TreeMap: {First=1,　Fourth=2,　Second=2, Third=3}
Usar el método subMap():
Usar el valor booleano por defecto: {Fourth=4,　Second=2}
Especificar el valor booleano: {Second=2, Third=3}

Otros métodos de TreeMap

Comparador TreeMap

En todos los ejemplos anteriores, los elementos del TreeMap se ordenan naturalmente (en orden ascendente). Pero también podemos definir el orden de las claves.

Para esto, necesitamos crear nuestra propia clase comparadora basada en la forma en que se ordenan las claves en el árbol. Por ejemplo,

import java.util.TreeMap;
import java.util.Comparator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Crear un TreeMap con un comparador personalizado
　　　　　　　　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);
　　　　}
　　　　//Crear una clase comparadora
　　　　public static class CustomComparator implements Comparator<String> {
　　　　　　　　@Override
　　　　　　　　public　int　compare(String　number1,　String　number2)　{
　　　　　　　　　　　　int　value　=　　number1.compareTo(number2);
　　　　　　　　　　　　//Los elementos se ordenan al revés
　　　　　　　　　　　　if　(value　>　0)　{
　　　　　　　　　　　　　　　　return　-1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else　if　(value　<　0)　{
　　　　　　　　　　　　　　　　return　1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else　{
　　　　　　　　　　　　　　　　return　0;
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

Resultado de salida

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

En el ejemplo anterior, creamos un treemap y pasamos la clase CustomComparator como parámetro.

La clase CustomComparator implementa el interfaz Comparator.

Luego, reescribe el método compare() en orden inverso.