Métodos especiales de Java TreeMap

TreeMap en Java se usa para implementar la interfaz Map y NavigableMap junto con AbstractMap Class . El mapa se ordena según el orden natural de sus claves, o mediante un comparador proporcionado en el momento de la creación del mapa, según el constructor que se utilice. Debido a la implementación de la interfaz NavigableMap y los datos ordenados, TreeMap proporciona ciertas funciones especiales que no están presentes en ninguna otra implementación de mapa.

Método 1: primera clave()

Devuelve la primera clave (más baja) actualmente en el mapa.

Sintaxis: 

public K firstKey()

Valor de retorno: la primera clave (la más baja) actualmente en este mapa.

Nota: se lanza NoSuchElementException si este mapa está vacío.

Ejemplo:

//  Java Program to illustrate firstKey() method of TreeMap
 
// Importing input output classes
import java.io.*;
// Importing treeMap class from java.util package
import java.util.TreeMap;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of TreeMap of type Character
        // and String
        TreeMap<Character, Integer> treeMap
            = new TreeMap<>();
 
        // Inserting elements to the object created above
 
        // Custom entries
        treeMap.put('A', 1);
        treeMap.put('F', 5);
        treeMap.put('M', 2);
        treeMap.put('K', 9);
        treeMap.put('G', 4);
        treeMap.put('J', 7);
 
        // Display all the elements in the object of TreeMap
        System.out.println("Tree Map : " + treeMap);
 
        // Print and display the lowest key
        // using firstkey() method
        System.out.println("Lowest Key is : "
                           + treeMap.firstKey());
    }
}

Tree Map : {A=1, F=5, G=4, J=7, K=9, M=2}
Lowest Key is : A

Método 2: última clave()

El java.util.TreeMap.lastKey() se usa para recuperar la última o la clave más alta presente en el mapa.

Sintaxis:  

tree_map.lastKey();

Valor devuelto: El método devuelve la última clave presente en el mapa.

Excepción: el método arroja NoSuchElementException si el mapa está vacío.

Ejemplo:

// Java Program to illustrate lastKey() Method in TreeMap
 
// Importing input output classes
import java.io.*;
// Importing TreeMap class from java.util package
import java.util.TreeMap;
 
// Main Class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of TreeMap of type Character
        // and Integer
        TreeMap<Character, Integer> treeMap
            = new TreeMap<>();
 
        // Adding elements to the object created above
        // Custom entries
        treeMap.put('A', 1);
        treeMap.put('F', 5);
        treeMap.put('M', 2);
        treeMap.put('K', 9);
        treeMap.put('G', 4);
        treeMap.put('J', 7);
 
        // Print and display all the elements in the TreeMap
        System.out.println("Tree Map : " + treeMap);
 
        // Print the highest key in the TreeMap
        // using lastKey() method
        System.out.println("Highest Key is : "
                           + treeMap.lastKey());
    }
}

Tree Map : {A=1, F=5, G=4, J=7, K=9, M=2}
Highest Key is : M

Método 3: headMap (objeto key_value)

El método java.util.TreeMap.headMap( key_point ) de la clase TreeMap se usa para obtener todos los pares o partes del mapa estrictamente menos que el parámetro key_value. El parámetro mencionado se excluye del TreeMap recién preparado. Dado que el conjunto está respaldado por el mapa, cualquier cambio en el mapa se refleja en el otro mapa y viceversa.

Sintaxis:

sorted_map = old_treemap.headMap(key_point)

Parámetros: El método toma un parámetro key_point del tipo de clave tomada en el TreeMap y hace referencia al punto, hasta el cual se devolverá el par clave-valor.

Valor devuelto: el método devuelve la parte del mapa de árbol cuyas claves son estrictamente menores que las de key_point.

Excepciones: el método arroja tres tipos de excepciones: 

• ClassCastException: esta excepción se lanza cuando key_point no es compatible o comparable con el comparador de mapas.
• NullPointerException: esta excepción se lanza cuando el punto clave es nulo.
• IllegalArgumentException: esta excepción se lanza cuando key_point está fuera de límite o fuera del límite del rango del mapa.

Ejemplo:

// Java Program to illustrate headMap() method of TreeMap
 
// Importing input output classes
import java.io.*;
// Importing TreeMap class from java.util package
import java.util.TreeMap;
 
// Main Class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of TreeMap of character and
        // Integer type
        TreeMap<Character, Integer> treeMap
            = new TreeMap<>();
 
        // Adding elements to the object of TreeMap
        // Custom entries
        treeMap.put('A', 1);
        treeMap.put('F', 5);
        treeMap.put('M', 2);
        treeMap.put('K', 9);
        treeMap.put('G', 4);
        treeMap.put('J', 7);
 
        // Print and display all elements in the object
        System.out.println("Tree Map : " + treeMap);
 
        // Print elements inclusive of key value passed
        // using headMap() method
        System.out.println(
            "Head Map exclusive of the key value : "
            + treeMap.headMap('G'));
 
        // Similarly to include the value passed
        // We can add a boolean argument as
        System.out.println(
            "Head Map inclusive of the key value : "
            + treeMap.headMap('G', true));
    }
}

Tree Map : {A=1, F=5, G=4, J=7, K=9, M=2}
Head Map exclusive of the key value : {A=1, F=5}
Head Map inclusive of the key value : {A=1, F=5, G=4}

Método 4: submapa (K startKey, K endKey)

El método java.util.TreeMap.subMap( K startKey, K endKey ) en Java se usa para devolver la parte o porción del mapa definida por el rango especificado de claves en el parámetro. Cualquier cambio realizado en uno u otro mapa reflejará el cambio en el otro mapa.

Sintaxis:

Tree_Map.subMap(K startKey, K endKey)

 Parámetros: El método toma dos parámetros de tipo Clave:

• startKey: se refiere al punto de inicio o extremo inferior del mapa, incluidos los puntos que se van a considerar.
• endKey: Esto se refiere al punto final o al extremo superior del mapa excluyendo los puntos que se van a considerar.

Nota: si startKey es igual a endKey, se devuelve un mapa nulo.

Valor devuelto: el método devuelve otro mapa que contiene la parte o porción del mapa dentro del rango especificado.

Excepciones: el método arroja tres tipos de excepciones:

• ClassCastException: esta excepción se lanza si los parámetros mencionados en el método no se pueden comparar con las claves de este mapa.
• NullPointerException: esta excepción se lanza si alguno de los parámetros es de tipo nulo y el mapa no acepta ningún valor nulo.
• IllegalArgumentException: esta excepción se lanza si los parámetros mencionados están fuera de rango o si el extremo inferior es mayor que el extremo superior.

 Ejemplo:

// Java Program to illustrate subMap() Method in TreeMap
 
// Importing input output classes
import java.io.*;
// Importing TreeMap class from java.util package
import java.util.TreeMap;
 
// Main Class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of TreeMap
        // Declaring object of Character and Integer type
        TreeMap<Character, Integer> treeMap
            = new TreeMap<>();
 
        // Adding elements to the TreeMap object
        // Custom entries
        treeMap.put('A', 1);
        treeMap.put('F', 5);
        treeMap.put('M', 2);
        treeMap.put('K', 9);
        treeMap.put('G', 4);
        treeMap.put('J', 7);
 
        // Print and display all elements of the TreeMap
        System.out.println("Tree Map : " + treeMap);
 
        // Print and display commands illustrating subMap()
        // method
        System.out.println(
            "Submap between the F(inclusive) and K(exclusive) : "
            + treeMap.subMap('F', 'K'));
        System.out.println(
            "Submap between the F(inclusive) and K(inclusive) : "
            + treeMap.subMap('F', true, 'K', true));
        System.out.println(
            "Submap between the F(exclusive) and K(inclusive) : "
            + treeMap.subMap('F', false, 'K', true));
        System.out.println(
            "Submap between the F(exclusive) and K(inclusive) : "
            + treeMap.subMap('F', false, 'K', true));
    }
}

Tree Map : {A=1, F=5, G=4, J=7, K=9, M=2}
Submap between the F(inclusive) and K(exclusive) : {F=5, G=4, J=7}
Submap between the F(inclusive) and K(inclusive) : {F=5, G=4, J=7, K=9}
Submap between the F(exclusive) and K(inclusive) : {G=4, J=7, K=9}
Submap between the F(exclusive) and K(inclusive) : {G=4, J=7, K=9}

Método 5: clave superior()

El métodohigherKey() se usa para devolver la clave mínima estrictamente mayor que la clave dada, o nulo si no existe tal clave.

Ejemplo:

// Java Program to illustrate higherKey() method in TreeMap
 
// Importing input output classes
import java.io.*;
// Importing TreeMap class from java.util package
import java.util.TreeMap;
 
// Main Class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of TreeMap object
        TreeMap<Character, Integer> treeMap
            = new TreeMap<>();
 
        // Adding elements to TreeMap objects
        // Custom entries
        treeMap.put('A', 1);
        treeMap.put('F', 5);
        treeMap.put('M', 2);
        treeMap.put('K', 9);
        treeMap.put('G', 4);
        treeMap.put('J', 7);
 
        // Print and display all TreeMap elements
        System.out.println("Tree Map : " + treeMap);
 
        // Print and display the higher key
        // using higherKey() method
        System.out.println("Higher key for F : "
                           + treeMap.higherKey('F'));
    }
}

Tree Map : {A=1, F=5, G=4, J=7, K=9, M=2}
Higher key for F : G

Método 6: método  de clave de techo (clave)

La función ceilingKey() devuelve la clave mínima mayor o igual que la clave dada o nula si dicha clave está ausente.

Ejemplo:

// Java Program to illustrate ceilingKey() Method in TreeMap
 
// Importing input output classes
import java.io.*;
// Importing treeMap class from java.util package
import java.util.TreeMap;
 
// main class
class GFG {
 
    // main driver method
    public static void main(String[] args)
    {
        // Creating an object of TreeMap object
        // Declaring object of Character and Integer type
        TreeMap<Character, Integer> treeMap
            = new TreeMap<>();
 
        // Adding elements to the object created above
        // Custom entries
        treeMap.put('A', 1);
        treeMap.put('F', 5);
        treeMap.put('M', 2);
        treeMap.put('K', 9);
        treeMap.put('G', 4);
        treeMap.put('J', 7);
 
        // print and display all elements of the treeMap
        // object
        System.out.println("Tree Map : " + treeMap);
 
        // Print and display ceiling key among all entries
        // using ceilingKey() method
 
        // Case 1
        System.out.println("Ceiling key for D : "
                           + treeMap.ceilingKey('D'));
 
        // Case 2
        System.out.println("Ceiling key for F : "
                           + treeMap.ceilingKey('F'));
    }
}

Tree Map : {A=1, F=5, G=4, J=7, K=9, M=2}
Ceiling key for D : F
Ceiling key for F : F

Método 7: método lowerKey  (tecla)

El método lowerKey() se usa para devolver la clave mayor estrictamente menor que la clave dada, pasada como parámetro.

Ejemplo:

// Java Program to illustrate lowerkey() method in TreeMap
 
// Importing input output classes
import java.io.*;
// Importing TreeMap class from java.util package
import java.util.TreeMap;
 
// Main Class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of TreeMap
        // Declaring object of type - Character and Integer
        TreeMap<Character, Integer> treeMap
            = new TreeMap<>();
 
        // Adding elements to above object
        // Custom entries
        treeMap.put('A', 1);
        treeMap.put('F', 5);
        treeMap.put('M', 2);
        treeMap.put('K', 9);
        treeMap.put('G', 4);
        treeMap.put('J', 7);
 
        // print and display the TreeMap elements
        System.out.println("Tree Map : " + treeMap);
 
        // Print and display the lower key
        // using lowerKey() method
        System.out.println("Lower key for N : "
                           + treeMap.lowerKey('N'));
        System.out.println("Lower key for M : "
                           + treeMap.lowerKey('M'));
    }
}

Tree Map : {A=1, F=5, G=4, J=7, K=9, M=2}
Lower key for N : M
Lower key for M : K

Método 8: FloorKey (clave) 

El método floorKey() se utiliza para devolver la clave mayor menor o igual que la clave dada del parámetro.

Ejemplo:

// Java Program to illustrate floorKey() method in TreeMap
 
// Importing input output classes
import java.io.*;
// Importing Treemap class from java.util package
import java.util.TreeMap;
 
// Main Class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of TreeMap of character and
        // Integer type
        TreeMap<Character, Integer> treeMap
            = new TreeMap<>();
 
        // Adding elements to TreeMap
        // Custom entries
        treeMap.put('A', 1);
        treeMap.put('F', 5);
        treeMap.put('M', 2);
        treeMap.put('K', 9);
        treeMap.put('G', 4);
        treeMap.put('J', 7);
 
        // Print and display the treeMap
        System.out.println("Tree Map : " + treeMap);
 
        // Print and display the floor key
        // using the floorKey() method
        System.out.println("Floor key for N : "
                           + treeMap.floorKey('N'));
       
        System.out.println("Floor key for M : "
                           + treeMap.floorKey('M'));
    }
}

Tree Map : {A=1, F=5, G=4, J=7, K=9, M=2}
Floor key for N : M
Floor key for M : M