NavigableSet em Java
Em Java o Conjunto Navegável é um subtipo do Conjunto ordenado interface. Ele nos permite realizar várias operações, como obter as correspondências mais próximas para uma determinada iteração de ordem decrescente de elemento e outras. Ele fornece métodos para navegar pelos elementos do conjunto.
Por exemplo A interface NavigableSet nos permite navegar pelo conjunto em ordem crescente e decrescente, ao contrário do SortedSet, que suporta apenas a ordem crescente. As classes que implementam a interface NavigableSet são Conjunto de árvores e ConcurrentSkipListSet
- NavigableSet estende SortedSet e, portanto, fornece métodos como first() last() headSet() tailSet() etc.
- Ele permite que você navegue em ambas as direções em ordem crescente e decrescente
- A implementação mais comum de NavigableSet é TreeSet.
Exemplo: Este exemplo demonstra a criação de um NavigableSet usando TreeSet e a adição de elementos a ele que os classifica automaticamente em ordem crescente.
Java // Java program to demonstrates // the working of NavigableSet import java.util.* ; public class Geeks { public static void main ( String [] args ) { NavigableSet < Integer > ns = new TreeSet <> (); // Add elements to the set ns . add ( 10 ); ns . add ( 20 ); ns . add ( 30 ); ns . add ( 40 ); ns . add ( 50 ); System . out . println ( 'Navigable Set: ' + ns ); } }
Saída
Navigable Set: [10 20 30 40 50]
O diagrama abaixo demonstra a estrutura de herança na estrutura de coleção Java relacionada a conjuntos.
TreeSet é uma classe que implementa Conjunto Navegável que por sua vez estende SortedSet que estende Definir .
Declaração de NavigableSet
Em Java, a declaração de NavigableSet pode ser declarada como:
Conjunto Navegável
setNome;
Observação: ' Type' é o tipo de elemento no conjunto (por exemplo, String inteira, etc.) e setName é o nome da variável.
Criando objetos NavigableSet
Não podemos criar um NavigableSet diretamente, pois é uma interface. Em vez disso, usamos uma classe como Conjunto de árvores que o implementa. Com a ajuda de genéricos podemos definir os tipos de objetos que o conjunto irá armazenar. Este conjunto de tipo seguro pode ser definido como:
Conjunto Navegável
conjunto = novo TreeSet ();
Exemplo: Este exemplo demonstra como usar vários métodos de NavigableSet como descedingSet() tailSet() lower() pollFirst() e pollLast() para manipular e navegar em um conjunto classificado na ordem normal e reversa.
Java // Java Program to demostrates the // working of various methods of NavigableSet import java.util.NavigableSet ; import java.util.TreeSet ; public class Geeks { 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 > revNs = ns . descendingSet (); // Print the normal and reverse views System . out . println ( 'Normal order: ' + ns ); System . out . println ( 'Reverse order: ' + revNs ); NavigableSet < Integer > t = ns . tailSet ( 3 true ); System . out . println ( '3 or more: ' + t ); 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 ()); } }
Saída:
Executando várias operações no NavigableSet
1. Adicionando Elementos: Podemos usar o adicionar() método para inserir elementos no NavigableSet. Os elementos são armazenados na ordem de classificação, nenhuma duplicata é permitida e valores nulos também não são aceitos pelo NavigableSet.
Exemplo: Este exemplo demonstra a adição de elementos a um NavigableSet usando add() onde as duplicatas são ignoradas e os elementos são classificados em ordem crescente.
Java // Java Program to demonstrates the working of add() import java.util.* ; import java.io.* ; class Geeks { 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 ( 'NavigableSet: ' + ts ); } }
Saída
NavigableSet: [A B C]
2. Acessando Elementos: Depois de adicionar os elementos, se desejarmos acessá-los, podemos usar métodos embutidos como contém() primeiro() durar() etc.
Exemplo: Este exemplo demonstra a adição de elementos a um NavigableSet, verificando a existência de um elemento e recuperando o primeiro e o último elemento.
Java // Java program to demonstrates the // working of contains() first() and last() method import java.util.* ; import java.io.* ; class Geeks { 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 ( 'NavigableSet: ' + ts ); String s = 'D' ; // Check if the above string exists in // the NavigableSet or not System . out . println ( 'D exists in the NavigableSet?: ' + ts . contains ( s )); // Print the first element in // the NavigableSet System . out . println ( 'First Element of NavigableSet: ' + ts . first ()); // Print the last element in // the NavigableSet System . out . println ( 'Last Element of NavigableSet: ' + ts . last ()); } }
Saída
NavigableSet: [A B C] D exists in the NavigableSet?: false First Element of NavigableSet: A Last Element of NavigableSet: C
3. Removendo Elementos: Os valores podem ser removidos do NavigableSet usando o remover() enquetePrimeiro() enqueteÚltima() .
Exemplo: Este exemplo demonstra a remoção de elementos do NavigableSet.
Java // Java Program to demonstrates the working of remove() // pollFirst() and pollLast() method import java.io.* ; import java.util.* ; class Geeks { 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 ( 'NavigableSet: ' + 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 ); } }
Saída
NavigableSet: [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 Elementos: Existem várias maneiras de iterar pelo NavigableSet. O mais famoso é usar o aprimorado para loop.
Exemplo: Este exemplo demonstra a adição de elementos a um NavigableSet e a iteração por ele em ordem crescente.
Java // Java Program to iterate through NavigableSet import java.util.* ; import java.io.* ; class Geeks { 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 i : ts ) System . out . print ( i + ' ' ); } }
Saída
A B C D E Z
Métodos
A seguir estão os métodos presentes na interface NavigableSet.
| Métodos | Descrição |
|---|---|
| teto(E e) | Retorna o menor elemento neste conjunto maior ou igual ao elemento fornecido ou nulo se tal elemento não existir. |
| descendenteIterator() | Retorna um iterador sobre os elementos deste conjunto em ordem decrescente. |
| conjunto descendente() | Retorna uma visualização de ordem inversa dos elementos contidos neste conjunto. |
| chão(E e) | Retorna o maior elemento deste conjunto menor ou igual ao elemento fornecido ou nulo se tal elemento não existir. |
| headSet(E toElement) | Retorna uma visualização da parte deste conjunto cujos elementos são estritamente menores que toElement. |
| headSet(E toElement booleano inclusive) | Retorna uma visualização da parte deste conjunto cujos elementos são menores que (ou iguais se inclusive for verdadeiro) toElement. |
| superior(E e) | Retorna o menor elemento neste conjunto estritamente maior que o elemento fornecido ou nulo se tal elemento não existir. |
| iterador() | Retorna um iterador sobre os elementos deste conjunto em ordem crescente. |
| inferior(E e) | Retorna o maior elemento neste conjunto estritamente menor que o elemento fornecido ou nulo se tal elemento não existir. |
| enquetePrimeiro() | Recupera e remove o primeiro elemento (mais baixo) ou retorna nulo se este conjunto estiver vazio. |
| enqueteÚltima() | Recupera e remove o último elemento (mais alto) ou retorna nulo se este conjunto estiver vazio. |
| subSet(E fromElement booleano deInclusivo E paraElemento booleano paraInclusivo) | Retorna uma visualização da parte deste conjunto cujos elementos variam de fromElement a toElement. |
| subSet (E do Elemento E para o Elemento) | Retorna uma visualização da parte deste conjunto cujos elementos variam de fromElement inclusive a toElement exclusivo. |
| tailSet(E fromElement) | Retorna uma visualização da parte deste conjunto cujos elementos são maiores ou iguais a fromElement. |
| tailSet(E fromElement booleano inclusive) | Retorna uma visualização da parte deste conjunto cujos elementos são maiores que (ou iguais se inclusive for verdadeiro) fromElement. |
Métodos herdados da interface java.util.SortedSet
| Método | Descrição |
|---|---|
| comparador() | Este método retorna o comparador usado para ordenar os elementos deste conjunto ou nulo se este conjunto utiliza a ordenação natural de seus elementos. |
| primeiro() | Este método retorna o primeiro elemento (mais baixo) presente neste conjunto. |
| durar() | Este método retorna o último elemento (mais alto) presente no conjunto. |
| divisor() | Cria um Spliterator sobre os elementos deste conjunto classificado. |
Métodos herdados da interface java.util.Set
| Método | Descrição |
|---|---|
| adicionar (elemento) | Este método é usado para adicionar um elemento específico ao conjunto. A função adiciona o elemento apenas se o elemento especificado ainda não estiver presente no conjunto, caso contrário, a função retornará False se o elemento já estiver presente no conjunto. |
| adicionarTodos(coleção) | Este método é usado para anexar todos os elementos da coleção mencionada ao conjunto existente. Os elementos são adicionados aleatoriamente sem seguir nenhuma ordem específica. |
| claro() | Este método é usado para remover todos os elementos do conjunto, mas não para excluí-lo. A referência para o conjunto ainda existe. |
| contém (elemento) | Este método é usado para verificar se um elemento específico está presente no Conjunto ou não. |
| contémTodos(coleção) | Este método é utilizado para verificar se o conjunto contém ou não todos os elementos presentes em uma determinada coleção. Este método retorna verdadeiro se o conjunto contiver todos os elementos e retorna falso se algum dos elementos estiver faltando. |
| é igual() | Compara o objeto especificado com este conjunto quanto à igualdade. |
| código hash() | Este método é usado para obter o valor hashCode para esta instância do Conjunto. Ele retorna um valor inteiro que é o valor hashCode para esta instância do Conjunto. |
| estáVazio() | Este método é usado para verificar se um NavigableSet está vazio ou não. |
| remover (elemento) | Este método é usado para remover um determinado elemento do conjunto. Este método retorna True se o elemento especificado estiver presente no Set, caso contrário, retorna False. |
| removerTodos(coleção) | Este método é utilizado para remover todos os elementos da coleção que estão presentes no conjunto. Este método retorna verdadeiro se este conjunto for alterado como resultado da chamada. |
| reterTudo(coleção) | Este método é usado para reter todos os elementos do conjunto mencionados em uma determinada coleção. Este método retorna verdadeiro se este conjunto for alterado como resultado da chamada. |
| tamanho() | Este método é usado para obter o tamanho do conjunto. Isso retorna um valor inteiro que significa o número de elementos. |
| toArray() | Este método é usado para formar um array com os mesmos elementos do Conjunto. |
| toArray(T[] a) | Retorna um array contendo todos os elementos deste conjunto; o tipo de tempo de execução da matriz retornada é o da matriz especificada. |
Métodos declarados na interface java.util.Collection
| Método | Descrição |
|---|---|
| paraleloStream() | Retorna um Stream possivelmente paralelo com esta coleção como origem. |
| removeIf(Predicado filtro) | Remove todos os elementos desta coleção que satisfazem o predicado fornecido. |
| fluxo() | Retorna um Stream sequencial com esta coleção como origem. |
| toArray?(IntFunction | Retorna uma matriz contendo todos os elementos desta coleção usando a função geradora fornecida para alocar a matriz retornada. |
Métodos declarados na interface java.lang.Iterable
| Método | Descrição |
|---|---|
| forEach(Consumidor Ação) | Executa a ação fornecida para cada elemento do Iterable até que todos os elementos tenham sido processados ou a ação gere uma exceção. |
