Interfaz NavigableMap en Java con ejemplo

La interfaz NavigableMap es miembro de Java Collection Framework . Pertenece al paquete java.util y es una extensión de SortedMap que proporciona métodos de navegación convenientes como lowerKey, FloorKey, CeilingKey y HigherKey, y junto con este popular método de navegación. También proporciona formas de crear un submapa a partir de un mapa existente en Java, por ejemplo, headMap cuyas claves son menores que la clave especificada, tailMap cuyas claves son mayores que la clave especificada y un submapa que contiene estrictamente claves que se encuentran entre toKey y fromKey. 
Una clase de ejemplo que implementa NavigableMap es TreeMap .

Declaración:

public interface NavigableMap<K,V> extends SortedMap<K,V>

Aquí, K es el tipo de objeto clave y V es el tipo de objeto de valor.

Jerarquía de NavigableMap

Implementa las interfaces Map<K,V> , SortedMap<K,V> . ConcurrentNavigableMap<K,V> extiende NavigableMap. ConcurrentSkipListMap y TreeMap implementan NavigableMap.

Ejemplo:

// Java program to demonstrate
// the NavigableMap interface
import java.util.NavigableMap;
import java.util.TreeMap;
 
public class NavigableMapExample {
 
    public static void main(String[] args)
    {
        // Instantiate an object
        // Since NavigableMap
        // is an interface so we
        // use TreeMap
        NavigableMap<String, Integer> nm
            = new TreeMap<String, Integer>();
 
        // Add elements using put() method
        nm.put("C", 888);
        nm.put("Y", 999);
        nm.put("A", 444);
        nm.put("T", 555);
        nm.put("B", 666);
        nm.put("A", 555);
 
        // Print the contents on the console
        System.out.println("Mappings of NavigableMap : "
                           + nm);
 
        System.out.printf("Descending Set  : %s%n",
                          nm.descendingKeySet());
        System.out.printf("Floor Entry  : %s%n",
                          nm.floorEntry("L"));
        System.out.printf("First Entry  : %s%n",
                          nm.firstEntry());
        System.out.printf("Last Key : %s%n", nm.lastKey());
        System.out.printf("First Key : %s%n",
                          nm.firstKey());
        System.out.printf("Original Map : %s%n", nm);
        System.out.printf("Reverse Map : %s%n",
                          nm.descendingMap());
    }
}

 
Producción:

Mappings of NavigableMap : {A=555, B=666, C=888, T=555, Y=999}
Descending Set  : [Y, T, C, B, A]
Floor Entry  : C=888
First Entry  : A=555
Last Key : Y
First Key : A
Original Map : {A=555, B=666, C=888, T=555, Y=999}
Reverse Map : {Y=999, T=555, C=888, B=666, A=555}

Implementando Clases

NavigableMap tiene dos clases de implementación que son ConcurrentSkipListMap y TreeMap . TreeMap es una implementación de NavigableMap basada en un árbol rojo-negro y se ordena de acuerdo con 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. TreeMap tiene el costo de tiempo esperado de log(n) para las operaciones de inserción, eliminación y acceso. TreeMap no está sincronizado y tiene que hacerse externamente.

Sintaxis:

NavigableMap<K, V> objectName = new TreeMap<K, V>();

Operaciones básicas en NavigableMap

1. Agregar elementos

Para agregar elementos a un NavigableMap podemos usar cualquier método de la interfaz del Mapa. El siguiente código muestra cómo usarlos. Puede observar en el código que la orden de inserción no se conserva. Cuando no se proporciona un Comparador en el momento de la construcción, se sigue el orden natural. 

// Java program for adding elements
// to a NavigableMap
import java.util.*;
 
class AddingElementsExample {
    public static void main(String args[])
    {
 
        // Instantiate an object
        // Since NavigableMap is an interface
        // We use TreeMap
        NavigableMap<Integer, String> nmap
            = new TreeMap<Integer, String>();
 
        // Add elements using put()
        nmap.put(3, "Geeks");
        nmap.put(2, "For");
        nmap.put(1, "Geeks");
 
        // Print the contents on the console
        System.out.println("Mappings of NavigableMap : "
                           + nmap);
    }
}

 
Producción:

Mappings of NavigableMap : {1=Geeks, 2=For, 3=Geeks}

2. Eliminación de elementos

Para eliminar elementos también usamos métodos de la interfaz Map, ya que NavigableMap es un descendiente de Map. Podemos usar el método remove() que toma el valor de la clave y elimina la asignación de la clave de este diagrama de árbol si está presente en el mapa. Podemos usar clear() para eliminar todos los elementos del mapa.
 

// Java Program for deleting
// elements from NavigableMap
import java.util.*;
 
class RemovingElementsExample {
   
    public static void main(String args[])
    {
        // Instantiate an object
        // Since NavigableMap
        // is an interface
        // We use TreeMap
        NavigableMap<Integer, String> nmap
            = new TreeMap<Integer, String>();
 
        // Add elements using put()
        nmap.put(3, "Geeks");
        nmap.put(2, "Geeks");
        nmap.put(1, "Geeks");
        nmap.put(4, "For");
 
        // Print the contents on the console
        System.out.println("Mappings of NavigableMap : "
                           + nmap);
 
        // Remove elements using remove()
        nmap.remove(4);
 
        // Print the contents on the console
        System.out.println(
            "\nNavigableMap, after remove operation : "
            + nmap);
 
        // Clear the entire map using clear()
        nmap.clear();
        System.out.println(
            "\nNavigableMap, after clear operation : "
            + nmap);
    }
}

 
Producción:

Mappings of NavigableMap : {1=Geeks, 2=Geeks, 3=Geeks, 4=For}

NavigableMap, after remove operation : {1=Geeks, 2=Geeks, 3=Geeks}

NavigableMap, after clear operation : {}

3. Accediendo a los Elementos

Podemos acceder a los elementos de un NavigableMap usando el método get(), el ejemplo de esto se da a continuación.

// Java Program for accessing
// elements in a NavigableMap
 
import java.util.*;
 
public class AccessingElementsExample {
 
    public static void main(String[] args)
    {
        // Instantiate an object
        // Since NavigableMap is an interface
        // We use TreeMap
        NavigableMap<Integer, String> nmap
            = new TreeMap<Integer, String>();
 
        // Add elements using put()
        nmap.put(8, "Third");
        nmap.put(6, "Second");
        nmap.put(3, "First");
        nmap.put(11, "Fourth");
 
        // Accessing the elements using get()
        // with key as a parameter
        System.out.println(nmap.get(3));
        System.out.println(nmap.get(6));
        System.out.println(nmap.get(8));
        System.out.println(nmap.get(11));
 
        // Display the set of keys using keySet()
        System.out.println("\nThe NavigableMap key set: "
                           + nmap.keySet());
    }
}

 
Producción:

First
Second
Third
Fourth

The NavigableMap key set: [3, 6, 8, 11]

4. Atravesando

Podemos usar la interfaz Iterator para atravesar cualquier estructura del Framework de colección. Dado que los iteradores trabajan con un tipo de datos, usamos Entry< ? , ? > para resolver los dos tipos separados en un formato compatible. Luego, usando el método next() imprimimos los elementos del NavigableMap. Otra forma famosa es usar un ciclo for-each y obtener las claves. El valor de la clave se encuentra utilizando el método getValue().

// Java Program for traversing
// a NavigableMap
import java.util.*;
 
class TraversalExample {
   
    public static void main(String args[])
    {
        // Instantiate an object
        // Since NavigableMap is an interface
        // We use TreeMap
        NavigableMap<Integer, String> nmap
            = new TreeMap<Integer, String>();
 
        // Add elements using put()
        nmap.put(3, "Geeks");
        nmap.put(2, "For");
        nmap.put(1, "Geeks");
 
        // Create an Iterator over the
        // NavigableMap
        Iterator<NavigableMap.Entry<Integer, String> > itr
            = nmap.entrySet().iterator();
 
        System.out.println("Traversing using Iterator: ");
        // The hasNext() method is used to check if there is
        // a next element The next() method is used to
        // retrieve the next element
        while (itr.hasNext()) {
            NavigableMap.Entry<Integer, String> entry
                = itr.next();
            System.out.println("Key = " + entry.getKey()
                               + ", Value = "
                               + entry.getValue());
        }
 
        System.out.println("Traversing using for-each: ");
        // Iterate using for-each loop
        for (Map.Entry mapElement : nmap.entrySet()) {
            // get the key using getKey()
            int key = (int)mapElement.getKey();
 
            // Finding the value
            String value = (String)mapElement.getValue();
 
            System.out.println("Key = " + key
                               + ", Value = " + value);
        }
    }
}

 
Producción:

Traversing using Iterator:  
Key = 1, Value = Geeks
Key = 2, Value = For
Key = 3, Value = Geeks
Traversing using for-each:  
Key = 1, Value = Geeks
Key = 2, Value = For
Key = 3, Value = Geeks

Nota: Cada vez que decimos ‘elementos de NavigableMap’, debe tenerse en cuenta que los elementos se almacenan en el objeto de una clase de implementación de NavigableMap, en este caso TreeMap.

Métodos de NavigableMap

NavigableMap hereda métodos de la interfaz Mapa , interfaz SortedMap . Las interfaces principales proporcionan los métodos básicos para agregar elementos, eliminar elementos y atravesarlos. Los métodos de NavigableMap se dan en la siguiente tabla. Aquí,

• K – El tipo de claves en el mapa.
• V – El tipo de valores mapeados en el mapa.

Métodos heredados de la interfaz java.util.SortedMap

Métodos heredados de la interfaz java.util.Map

Referencia: https://docs.oracle.com/javase/8/docs/api/java/util/NavigableMap.html 
Este artículo es una contribución de Pratik Agarwal . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.