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 .
travessia inorder da árvore binária
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:
como converter de int para string em java
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() .
componentes do robô
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.
quão grande é o meu monitor
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 lista de dardos |
|---|---|
| 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(Predicadofiltro) | 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(ConsumidorAçã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. |