NavigableSet en Java con ejemplos

NavigableSet representa un conjunto navegable en Java Collection Framework . La interfaz NavigableSet hereda de la interfaz SortedSet . Se comporta como un SortedSet con la excepción de que tenemos métodos de navegación disponibles además de los mecanismos de clasificación de SortedSet. 
Por ejemplo, la interfaz NavigableSet puede navegar por el conjunto en orden inverso en comparación con el orden definido en SortedSet. Se puede acceder y recorrer un NavigableSet en orden ascendente o descendente. Las clases que implementan esta interfaz son TreeSet y ConcurrentSkipListSet .

Aquí, E es el tipo de elementos que mantiene este conjunto.

Todas las superinterfaces:

Colección<E>, Iterable<E>, Conjunto<E> , Conjunto ordenado<E>

Todas las clases de implementación conocidas:

ConcurrentSkipListSet , TreeSet<E>

Declaración: el NavigableSet se declara como

la interfaz pública NavigableSet<E> extiende SortedSet<E> 

Creación de objetos NavigableSet

Dado que NavigableSet es una interfaz, no se pueden crear objetos del tipo NavigableSet. Siempre necesitamos una clase que amplíe esta lista para crear un objeto. Y también, después de la introducción de Generics en Java 1.5, es posible restringir el tipo de objeto que se puede almacenar en el NavigableSet. Este conjunto de tipo seguro se puede definir como:

// Obj es el tipo de objeto que se almacenará en NavigableSet

NavigableSet<Obj> set = new TreeSet<Obj>();

Ejemplo:

// Java program to demonstrate
// the working of NavigableSet
import java.util.NavigableSet;
import java.util.TreeSet;
 
public class NavigableSetDemo
{
    public static void main(String[] args)
    {
        NavigableSet<Integer> ns = new TreeSet<>();
        ns.add(0);
        ns.add(1);
        ns.add(2);
        ns.add(3);
        ns.add(4);
        ns.add(5);
        ns.add(6);
 
        // Get a reverse view of the navigable set
        NavigableSet<Integer> reverseNs = ns.descendingSet();
 
        // Print the normal and reverse views
        System.out.println("Normal order: " + ns);
        System.out.println("Reverse order: " + reverseNs);
 
        NavigableSet<Integer> threeOrMore = ns.tailSet(3, true);
        System.out.println("3 or  more:  " + threeOrMore);
        System.out.println("lower(3): " + ns.lower(3));
        System.out.println("floor(3): " + ns.floor(3));
        System.out.println("higher(3): " + ns.higher(3));
        System.out.println("ceiling(3): " + ns.ceiling(3));
 
        System.out.println("pollFirst(): " + ns.pollFirst());
        System.out.println("Navigable Set:  " + ns);
 
        System.out.println("pollLast(): " + ns.pollLast());
        System.out.println("Navigable Set:  " + ns);
 
        System.out.println("pollFirst(): " + ns.pollFirst());
        System.out.println("Navigable Set:  " + ns);
 
        System.out.println("pollFirst(): " + ns.pollFirst());
        System.out.println("Navigable Set:  " + ns);
 
        System.out.println("pollFirst(): " + ns.pollFirst());
        System.out.println("Navigable Set:  " + ns);
 
        System.out.println("pollFirst(): " + ns.pollFirst());
        System.out.println("pollLast(): " + ns.pollLast());
    }
}

Normal order: [0, 1, 2, 3, 4, 5, 6]
Reverse order: [6, 5, 4, 3, 2, 1, 0]
3 or  more:  [3, 4, 5, 6]
lower(3): 2
floor(3): 3
higher(3): 4
ceiling(3): 3
pollFirst(): 0
Navigable Set:  [1, 2, 3, 4, 5, 6]
pollLast(): 6
Navigable Set:  [1, 2, 3, 4, 5]
pollFirst(): 1
Navigable Set:  [2, 3, 4, 5]
pollFirst(): 2
Navigable Set:  [3, 4, 5]
pollFirst(): 3
Navigable Set:  [4, 5]
pollFirst(): 4
pollLast(): 5

Realización de varias operaciones en NavigableSet

Dado que NavigableSet es una interfaz, solo se puede usar con una clase que implemente esta interfaz. TreeSet es la clase que implementa la interfaz NavigableSet. Ahora, veamos cómo realizar algunas operaciones de uso frecuente en el TreeSet.

1. Agregar elementos: para agregar un elemento al NavigableSet, podemos usar el método add() . Sin embargo, el orden de inserción no se conserva en el TreeSet. Internamente, para cada elemento, los valores se comparan y clasifican en orden ascendente. Debemos tener en cuenta que los elementos duplicados no están permitidos y todos los elementos duplicados se ignoran. Además, el NavigableSet no acepta valores nulos.

// Java code to demonstrate
// adding of elements in
// NavigableSet
import java.util.*;
import java.io.*;
 
class NavigableSetDemo {
 
    public static void main(String[] args)
    {
        NavigableSet<String> ts = new TreeSet<String>();
 
        // Elements are added using add() method
        ts.add("A");
        ts.add("B");
        ts.add("C");
        ts.add("A");
 
        System.out.println(ts);
    }
}

Producción:

[A, B, C]

2. Accediendo a los Elementos: Después de agregar los elementos, si deseamos acceder a los elementos, podemos usar métodos incorporados como contains(), first(), last(), etc.

• contiene()
• primero()
• ultimo()

// Java program to access
// the elements of NavigableSet
import java.util.*;
import java.io.*;
 
class NavigableSetDemo {
 
    public static void main(String[] args)
    {
        NavigableSet<String> ts = new TreeSet<String>();
 
        // Elements are added using add() method
        ts.add("A");
        ts.add("B");
        ts.add("C");
        ts.add("A");
 
        System.out.println("Navigable Set is " + ts);
 
        String check = "D";
 
        // Check if the above string exists in
        // the NavigableSet or not
        System.out.println("Contains " + check + " "
                           + ts.contains(check));
 
        // Print the first element in
        // the NavigableSet
        System.out.println("First Value " + ts.first());
 
        // Print the last element in
        // the NavigableSet
        System.out.println("Last Value " + ts.last());
    }
}

Producción:

Navigable Set is [A, B, C]
Contains D false
First Value A
Last Value C

3. Eliminación de los valores: los valores se pueden eliminar del NavigableSet utilizando los métodos remove(), pollFirst(), pollLast().

• retirar()
• sondearprimero()
• última encuesta()

// Java Program to remove the
// elements from NavigableSet
import java.util.*;
import java.io.*;
 
class NavigableSetDemo {
 
    public static void main(String[] args)
    {
        NavigableSet<String> ts = new TreeSet<String>();
 
        // Elements are added using add() method
        ts.add("A");
        ts.add("B");
        ts.add("C");
        ts.add("B");
        ts.add("D");
        ts.add("E");
 
        System.out.println("Initial TreeSet " + ts);
 
        // Removing the element b
        ts.remove("B");
 
        System.out.println("After removing element " + ts);
 
        // Remove the First element of TreeSet
        ts.pollFirst();
 
        System.out.println(
            "After the removal of First Element " + ts);
 
        // Remove the Last element of TreeSet
        ts.pollLast();
 
        System.out.println(
            "After the removal of Last Element " + ts);
    }
}

Producción:

Initial TreeSet [A, B, C, D, E]
After removing element [A, C, D, E]
After the removal of First Element [C, D, E]
After the removal of Last Element [C, D]

4. Iterando a través de NavigableSet: Hay varias formas de iterar a través de NavigableSet. El más famoso es usar el bucle for mejorado.

// Java program to iterate
// through NavigableSet
 
import java.util.*;
import java.io.*;
 
class NavigableSetDemo {
   
    public static void main(String[] args)
    {
        NavigableSet<String> ts = new TreeSet<String>();
 
        // Elements are added using add() method
        ts.add("C");
        ts.add("D");
        ts.add("E");
        ts.add("A");
        ts.add("B");
        ts.add("Z");
 
        // Iterating though the NavigableSet
        for (String value : ts)
            System.out.print(value + ", ");
        System.out.println();
    }
}

Producción:

A, B, C, D, E, Z,  

Métodos de conjunto navegable

Los siguientes son los métodos presentes en la interfaz NavigableSet. 

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

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

Métodos declarados en la interfaz java.util.Collection

Métodos declarados en la interfaz java.lang.Iterable

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.