Mapa de árbol de Java
Mapa de árbol de Java
En este tutorial, aprenderemos sobre la clase Java TreeMap y sus operaciones con la ayuda de ejemplos.
El TreeMap La clase del marco de colecciones de Java proporciona la implementación de la estructura de datos de árbol.
Implementa la interfaz NavigableMap.
Creación de un mapa de árbol
Para crear un TreeMap , debemos importar el java.util.TreeMap paquete primero. Una vez que importamos el paquete, así es como podemos crear un TreeMap en Java.
TreeMap<Key, Value> numbers = new TreeMap<>();
En el código anterior, hemos creado un TreeMap números con nombre sin ningún argumento. En este caso, los elementos en TreeMap se ordenan naturalmente (orden ascendente).
Sin embargo, podemos personalizar la clasificación de los elementos usando el Comparator interfaz. Aprenderemos sobre esto más adelante en este tutorial.
Aquí,
- Clave - un identificador único utilizado para asociar cada elemento (valor) en un mapa
- Valor - elementos asociados por claves en un mapa
Métodos de TreeMap
El TreeMap class proporciona varios métodos que nos permiten realizar operaciones en el mapa.
Insertar elementos en TreeMap
put()- inserta la asignación clave/valor especificada (entrada) en el mapaputAll()- inserta todas las entradas del mapa especificado a este mapaputIfAbsent()- inserta la asignación clave/valor especificada en el mapa si la clave especificada no está presente en el mapa
Por ejemplo,
import java.util.TreeMap;
class Main {
public static void main(String[] args) {
// Creating TreeMap of even numbers
TreeMap<String, Integer> evenNumbers = new TreeMap<>();
// Using put()
evenNumbers.put("Two", 2);
evenNumbers.put("Four", 4);
// Using putIfAbsent()
evenNumbers.putIfAbsent("Six", 6);
System.out.println("TreeMap of even numbers: " + evenNumbers);
//Creating TreeMap of numbers
TreeMap<String, Integer> numbers = new TreeMap<>();
numbers.put("One", 1);
// Using putAll()
numbers.putAll(evenNumbers);
System.out.println("TreeMap of numbers: " + numbers);
}
}
Salida
TreeMap of even numbers: {Four=4, Six=6, Two=2}
TreeMap of numbers: {Four=4, One=1, Six=6, Two=2}
Acceder a elementos de TreeMap
entrySet()- devuelve un conjunto de todas las asignaciones de clave/valor (entrada) de un mapa de árbolkeySet()- devuelve un conjunto de todas las claves de un mapa de árbolvalues()- devuelve un conjunto de todos los mapas de un mapa de árbol
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);
// Using entrySet()
System.out.println("Key/Value mappings: " + numbers.entrySet());
// Using keySet()
System.out.println("Keys: " + numbers.keySet());
// Using values()
System.out.println("Values: " + numbers.values());
}
}
Salida
TreeMap: {One=1, Three=3, Two=2}
Key/Value mappings: [One=1, Three=3, Two=2]
Keys: [One, Three, Two]
Values: [1, 3, 2]
get()- Devuelve el valor asociado a la clave especificada. Devuelve nulo si no se encuentra la clave.getOrDefault()- Devuelve el valor asociado a la clave especificada. Devuelve el valor predeterminado especificado si no se encuentra la clave.
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);
// Using get()
int value1 = numbers.get("Three");
System.out.println("Using get(): " + value1);
// Using getOrDefault()
int value2 = numbers.getOrDefault("Five", 5);
System.out.println("Using getOrDefault(): " + value2);
}
}
Salida
TreeMap: {One=1, Three=3, Two=2}
Using get(): 3
Using getOrDefault(): 5
Aquí, el getOrDefault() método no encuentra la clave Cinco . Por lo tanto, devuelve el valor predeterminado especificado 5 .
Eliminar elementos de TeeMap
remove(key)- devuelve y elimina la entrada asociada con la clave especificada de un TreeMapremove(key, value)- elimina la entrada del mapa solo si la clave especificada está asociada con el valor especificado y devuelve un 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);
// remove method with single parameter
int value = numbers.remove("Two");
System.out.println("Removed value: " + value);
// remove method with two parameters
boolean result = numbers.remove("Three", 3);
System.out.println("Is the entry {Three=3} removed? " + result);
System.out.println("Updated TreeMap: " + numbers);
}
}
Salida
TreeMap: {One=1, Three=3, Two=2}
Removed value = 2
Is the entry {Three=3} removed? True
Updated TreeMap: {One=1}
Reemplazar elementos de TreeMap
replace(key, value)- reemplaza el valor asignado por la clave especificada con el nuevo valorreplace(key, old, new)- reemplaza el valor anterior con el valor nuevo solo si el valor anterior ya está asociado con la clave especificadareplaceAll(function)- reemplaza cada valor del mapa con el resultado de la función especificada
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);
// Using replace()
numbers.replace("Second", 22);
numbers.replace("Third", 3, 33);
System.out.println("TreeMap using replace: " + numbers);
// Using replaceAll()
numbers.replaceAll((key, oldValue) -> oldValue + 2);
System.out.println("TreeMap using replaceAll: " + numbers);
}
}
Salida
Original TreeMap: {First=1, Second=2, Third=3}
TreeMap using replace(): {First=1, Second=22, Third=33}
TreeMap using replaceAll(): {First=3, Second=24, Third=35}
En el programa anterior, observe la declaración
numbers.replaceAll((key, oldValue) -> oldValue + 2);
Aquí, hemos pasado una expresión lambda como argumento.
El replaceAll() El método accede a todas las entradas del mapa. Luego reemplaza todos los elementos con los nuevos valores (devueltos de la expresión lambda).
Métodos de navegación
Desde el TreeMap clase implementa NavigableMap , proporciona varios métodos para navegar por los elementos del diagrama de árbol.
1. Primer y último método
firstKey()- devuelve la primera clave del mapafirstEntry()- devuelve el mapeo clave/valor de la primera clave del mapalastKey()- devuelve la última clave del mapalastEntry()- devuelve el mapeo clave/valor de la última clave del mapa
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);
// Using the firstKey() method
String firstKey = numbers.firstKey();
System.out.println("First Key: " + firstKey);
// Using the lastKey() method
String lastKey = numbers.lastKey();
System.out.println("Last Key: " + lastKey);
// Using firstEntry() method
System.out.println("First Entry: " + numbers.firstEntry());
// Using the lastEntry() method
System.out.println("Last Entry: " + numbers.lastEntry());
}
}
Salida
TreeMap: {First=1, Second=2, Third=3}
First Key: First
Last Key: Third
First Entry: First=1
Last Entry: Third=3
2. Métodos de Techo, Piso, Superior e Inferior
- clave superior() - Devuelve la clave más baja entre aquellas claves que son mayores que la clave especificada.
- entrada superior() - Devuelve una entrada asociada con una clave que es la más baja entre todas las claves mayores que la clave especificada.
- clave inferior() - Devuelve la clave mayor entre todas aquellas claves que son menores que la clave especificada.
- entrada inferior() - Devuelve una entrada asociada con una clave que es mayor entre todas aquellas claves que son menores que la clave especificada.
- clave de techo() - Devuelve la clave más baja entre aquellas claves que son mayores que la clave especificada. Si la clave pasada como argumento está presente en el mapa, devuelve esa clave.
- entrada de techo() - Devuelve una entrada asociada con una clave que es la más baja entre aquellas claves que son mayores que la clave especificada. Si una entrada asociada con la clave pasada un argumento está presente en el mapa, devuelve la entrada asociada con esa clave.
- clave del piso() - Devuelve la clave mayor entre aquellas claves que son menores que la clave especificada. Si la clave pasada como argumento está presente, devuelve esa clave.
- entrada de piso() - Devuelve una entrada asociada con una clave que es mayor entre aquellas claves que son menores que la clave especificada. Si la clave pasada como argumento está presente, devuelve 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);
// Using higher()
System.out.println("Using higherKey(): " + numbers.higherKey("Fourth"));
System.out.println("Using higherEntry(): " + numbers.higherEntry("Fourth"));
// Using lower()
System.out.println("\nUsing lowerKey(): " + numbers.lowerKey("Fourth"));
System.out.println("Using lowerEntry(): " + numbers.lowerEntry("Fourth"));
// Using ceiling()
System.out.println("\nUsing ceilingKey(): " + numbers.ceilingKey("Fourth"));
System.out.println("Using ceilingEntry(): " + numbers.ceilingEntry("Fourth"));
// Using floor()
System.out.println("\nUsing floorKey(): " + numbers.floorKey("Fourth"));
System.out.println("Using floorEntry(): " + numbers.floorEntry("Fourth"));
}
}
Salida
TreeMap: {First=1, Fourth=6, Second=5, Third=4}
Using higherKey(): Second
Using higherEntry(): Second=5
Using lowerKey(): First
Using lowerEntry(): First=1
Using ceilingKey(): Fourth
Using ceilingEntry(): Fourth=6
Using floorkey(): Fourth
Using floorEntry(): Fourth=6
3. Métodos pollFirstEntry() y pollLastEntry()
pollFirstEntry()- devuelve y elimina la entrada asociada a la primera clave del mapapollLastEntry()- devuelve y elimina la entrada asociada a la última clave del mapa
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);
//Using the pollFirstEntry() method
System.out.println("Using pollFirstEntry(): " + numbers.pollFirstEntry());
// Using the pollLastEntry() method
System.out.println("Using pollLastEntry(): " + numbers.pollLastEntry());
System.out.println("Updated TreeMap: " + numbers);
}
}
Salida
TreeMap: {First=1, Second=2, Third=3}
Using pollFirstEntry(): First=1
Using pollLastEntry(): Third=3
Updated TreeMap: {Second=2}
4. Métodos headMap(), tailMap() y subMap()
headMap(clave, valor booleano)
El headMap() El método devuelve todos los pares clave/valor de un mapa de árbol antes de la clave especificada (que se pasa como argumento).
El valor booleano el parámetro es opcional. Su valor por defecto es false .
Si true se pasa como un booleanValue , el método también incluye el par clave/valor del key que se pasa como argumento.
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("\nUsing headMap() Method:");
// Using headMap() with default booleanValue
System.out.println("Without boolean value: " + numbers.headMap("Fourth"));
// Using headMap() with specified booleanValue
System.out.println("With boolean value: " + numbers.headMap("Fourth", true));
}
}
Salida
TreeMap: {First=1, Fourth=4, Second=2, Third=3}
Using headMap() Method:
Without boolean value: {First=1}
With boolean value: {First=1, Fourth=4}
tailMap(clave, valor booleano)
El tailMap() El método devuelve todos los pares clave/valor de un mapa de árbol a partir de la clave especificada (que se pasa como argumento).
El valor booleano es un parámetro opcional. Su valor por defecto es true .
Si false se pasa como un booleanValue , el método no incluye el par clave/valor del key especificado .
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("\nUsing tailMap() Method:");
// Using tailMap() with default booleanValue
System.out.println("Without boolean value: " + numbers.tailMap("Second"));
// Using tailMap() with specified booleanValue
System.out.println("With boolean value: " + numbers.tailMap("Second", false));
}
}
Salida
TreeMap: {First=1, Fourth=4, Second=2, Third=3}
Using tailMap() Method:
Without boolean value: {Second=2, Third=3}
With boolean value: {Third=3}
submapa(k1, bV1, k2, bV2)
El subMap() método devuelve todas las entradas asociadas con claves entre k1 y k2 incluyendo la entrada de k1 .
El bV1 y bV2 son parámetros booleanos opcionales. El valor predeterminado de bV1 es true y el valor predeterminado de bV2 es false .
Si false se pasa como bV1 , el método devuelve todas las entradas asociadas con claves entre k1 y k2 sin incluir la entrada de k1 .
Si true se pasa como bV2 , el método devuelve todas las entradas asociadas con claves entre k1 y k2 incluyendo la entrada de k2 .
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("\nUsing subMap() Method:");
// Using subMap() with default booleanValue
System.out.println("Without boolean value: " + numbers.subMap("Fourth", "Third"));
// Using subMap() with specified booleanValue
System.out.println("With boolean value: " + numbers.subMap("Fourth", false, "Third", true));
}
}
Salida
TreeMap: {First=1, Fourth=2, Second=2, Third=3}
Using subMap() Method:
Without boolean value: {Fourth=4, Second=2}
With boolean value: {Second=2, Third=3}
Otros métodos de TreeMap
| Método | Descripción |
|---|---|
clone() | Crea una copia del TreeMap |
containsKey() | Busca el TreeMap para la clave especificada y devuelve un resultado booleano |
containsValue() | Busca el TreeMap para el valor especificado y devuelve un resultado booleano |
size() | Devuelve el tamaño del TreeMap |
clear() | Elimina todas las entradas del TreeMap |
Comparador de TreeMap
En todos los ejemplos anteriores, los elementos del mapa de árbol se ordenan de forma natural (en orden ascendente). Sin embargo, también podemos personalizar el orden de las teclas.
Para esto, necesitamos crear nuestra propia clase de comparación en función de qué claves se ordenan en un mapa de árbol. Por ejemplo,
import java.util.TreeMap;
import java.util.Comparator;
class Main {
public static void main(String[] args) {
// Creating a treemap with a customized comparator
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);
}
// Creating a comparator class
public static class CustomComparator implements Comparator<String> {
@Override
public int compare(String number1, String number2) {
int value = number1.compareTo(number2);
// elements are sorted in reverse order
if (value > 0) {
return -1;
}
else if (value < 0) {
return 1;
}
else {
return 0;
}
}
}
}
Salida
TreeMap: {Third=3, Second=2, Fourth=4, First=1}
En el ejemplo anterior, hemos creado un mapa de árbol pasando CustomComparator class como argumento.
El Comparador Personalizado clase implementa el Comparator interfaz.
Luego anulamos el compare() método para ordenar elementos en orden inverso.
Para obtener más información, visite Java Comparator (documentación oficial de Java).
Java