A Giava il Set navigabile è un sottotipo di Insieme ordinato interfaccia. Ci consente di eseguire varie operazioni come ottenere le corrispondenze più vicine per un dato elemento nell'iterazione dell'ordine discendente e altre. Fornisce metodi per navigare tra gli elementi del set.
Per esempio L'interfaccia NavigableSet ci consente di navigare attraverso l'insieme sia in ordine ascendente che discendente a differenza di SortedSet che supporta solo l'ordine crescente. Le classi che implementano l'interfaccia NavigableSet sono Set di alberi E ConcurrentSkipListSet
- NavigableSet estende SortedSet e quindi fornisce metodi come first() last() headSet() tailSet() ecc.
- Ti consente di navigare in entrambe le direzioni, in ordine ascendente e discendente
- L'implementazione più comune di NavigableSet è TreeSet.
Esempio: Questo esempio dimostra la creazione di un NavigableSet utilizzando TreeSet e l'aggiunta di elementi che li ordinano automaticamente in ordine 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); } }
Produzione
Navigable Set: [10 20 30 40 50]
Il diagramma seguente mostra la struttura di ereditarietà nel framework di raccolta di Java relativo agli insiemi.
TreeSet è una classe che implementa Set navigabile che a sua volta estende SortedSet che si estende Impostato .
alisa manyonok
Dichiarazione di NavigableSet
In Java la dichiarazione di NavigableSet può essere dichiarata come:
Set navigabile
setNome;
Nota: ' Type' è il tipo di elemento nel set (ad esempio, stringa intera, ecc.) e setName è il nome della variabile.
Creazione di oggetti NavigableSet
Non possiamo creare direttamente un NavigableSet poiché è un'interfaccia. Usiamo invece una classe come Set di alberi che lo implementa. Con l'aiuto dei generici possiamo definire il tipo di oggetti che il set memorizzerà. Questo set indipendente dai tipi può essere definito come:
Set navigabile
set = nuovo set di alberi ();
Esempio: Questo esempio dimostra come utilizzare vari metodi di NavigableSet come descedingSet() tailSet() lower() pollFirst() e pollLast() per manipolare e navigare in un set ordinato sia in ordine normale che inverso.
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()); } }
Produzione:
Esecuzione di varie operazioni su NavigableSet
1. Aggiunta di elementi: Possiamo usare il aggiungere() metodo per inserire elementi nel NavigableSet. Gli elementi vengono archiviati in ordine ordinato, non sono consentiti duplicati e anche i valori null non vengono accettati da NavigableSet.
Esempio: Questo esempio dimostra l'aggiunta di elementi a NavigableSet utilizzando add() dove i duplicati vengono ignorati e gli elementi vengono ordinati in ordine 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); } }
Produzione
NavigableSet: [A B C]
2. Accesso agli elementi: Dopo aver aggiunto gli elementi, se desideriamo accedere agli elementi, possiamo utilizzare metodi integrati come contiene() Primo() scorso() ecc.
Esempio: Questo esempio dimostra l'aggiunta di elementi a NavigableSet verificando l'esistenza di un elemento e recuperando il primo e l'ultimo 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()); } }
Produzione
NavigableSet: [A B C] D exists in the NavigableSet?: false First Element of NavigableSet: A Last Element of NavigableSet: C
3. Rimozione di elementi: I valori possono essere rimossi dal NavigableSet utilizzando il file rimuovere() sondaggioPrimo() sondaggioUltimo() .
Esempio: Questo esempio illustra la rimozione di elementi da 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); } }
Produzione
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. Elementi iterativi: Esistono vari modi per scorrere il NavigableSet. Il più famoso è usare il file migliorato per il ciclo.
Esempio: Questo esempio dimostra l'aggiunta di elementi a NavigableSet e l'iterazione in ordine 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 + ' '); } }
Produzione
A B C D E Z
Metodi
Di seguito sono riportati i metodi presenti nell'interfaccia NavigableSet.
Metodi | Descrizione |
|---|---|
| soffitto(E e) | Restituisce l'elemento minimo in questo insieme maggiore o uguale all'elemento specificato o null se tale elemento non esiste. |
| discendenteIteratore() | Restituisce un iteratore sugli elementi di questo set in ordine decrescente. |
| insieme discendente() | Restituisce una visualizzazione in ordine inverso degli elementi contenuti in questo insieme. |
| pavimento(E e) | Restituisce l'elemento più grande in questo insieme minore o uguale all'elemento specificato o null se tale elemento non esiste. |
| headSet(E inElemento) | Restituisce una visualizzazione della porzione di questo set i cui elementi sono strettamente inferiori a toElement. |
| headSet(E toElement booleano incluso) | Restituisce una visualizzazione della parte di questo insieme i cui elementi sono minori di (o uguali a, se inclusivo è vero) toElement. |
| più alto(E e) | Restituisce l'elemento minimo in questo insieme strettamente maggiore dell'elemento specificato o null se tale elemento non esiste. |
| iteratore() | Restituisce un iteratore sugli elementi di questo set in ordine crescente. |
| inferiore(E e) | Restituisce l'elemento più grande in questo insieme strettamente inferiore all'elemento specificato o null se tale elemento non esiste. |
| sondaggioPrimo() | Recupera e rimuove il primo elemento (il più basso) o restituisce null se questo set è vuoto. |
| sondaggioUltimo() | Recupera e rimuove l'ultimo elemento (il più alto) o restituisce null se questo set è vuoto. |
subSet(E fromElement booleano fromInclusive E toElement boolean toInclusive) | Restituisce una visualizzazione della porzione di questo set i cui elementi vanno da fromElement a toElement. |
| subSet(E daElemento E aElemento) | Restituisce una visualizzazione della parte di questo set i cui elementi vanno da fromElement inclusive a toElement Exclusive. |
| tailSet(E daElemento) | Restituisce una visualizzazione della parte di questo set i cui elementi sono maggiori o uguali a fromElement. |
| tailSet(E fromElement booleano incluso) | Restituisce una visualizzazione della parte di questo insieme i cui elementi sono maggiori di (o uguali a, se inclusivo è vero) daElemento. |
Metodi ereditati dall'interfaccia java.util.SortedSet
Metodo | Descrizione tipi di dati di riferimento in Java |
|---|---|
| comparatore() | Questo metodo restituisce il comparatore utilizzato per ordinare gli elementi in questo insieme o null se questo insieme utilizza l'ordinamento naturale dei suoi elementi. |
| Primo() | Questo metodo restituisce il primo elemento (più basso) presente in questo insieme. |
| scorso() | Questo metodo restituisce l'ultimo (più alto) elemento presente nell'insieme. |
| divisore() | Crea uno Spliterator sugli elementi in questo set ordinato. |
Metodi ereditati dall'interfaccia java.util.Set
Metodo | Descrizione |
|---|---|
| aggiungi(elemento) | Questo metodo viene utilizzato per aggiungere un elemento specifico al set. La funzione aggiunge l'elemento solo se l'elemento specificato non è già presente nel set altrimenti la funzione restituisce False se l'elemento è già presente nel Set. |
| aggiungiTutto(raccolta) | Questo metodo viene utilizzato per aggiungere tutti gli elementi della raccolta menzionata al set esistente. Gli elementi vengono aggiunti in modo casuale senza seguire alcun ordine specifico. |
| chiaro() | Questo metodo viene utilizzato per rimuovere tutti gli elementi dall'insieme ma non eliminare l'insieme. Il riferimento per il set esiste ancora. |
| contiene(elemento) | Questo metodo viene utilizzato per verificare se un determinato elemento è presente o meno nel Set. |
| contieneTutto(raccolta) | Questo metodo viene utilizzato per verificare se l'insieme contiene o meno tutti gli elementi presenti nella raccolta data. Questo metodo restituisce true se l'insieme contiene tutti gli elementi e restituisce false se manca uno qualsiasi degli elementi. |
| è uguale a() | Confronta l'oggetto specificato con questo set per verificarne l'uguaglianza. |
| codicehash() | Questo metodo viene utilizzato per ottenere il valore hashCode per questa istanza del Set. Restituisce un valore intero che è il valore hashCode per questa istanza del Set. |
| èVuoto() | Questo metodo viene utilizzato per verificare se un NavigableSet è vuoto o meno. |
| rimuovi (elemento) | Questo metodo viene utilizzato per rimuovere l'elemento specificato dall'insieme. Questo metodo restituisce True se l'elemento specificato è presente nel Set altrimenti restituisce False. |
| rimuovi tutto(raccolta) | Questo metodo viene utilizzato per rimuovere dalla collezione tutti gli elementi presenti nell'insieme. Questo metodo restituisce true se questo set è cambiato come risultato della chiamata. |
| keepAll(raccolta) | Questo metodo viene utilizzato per conservare tutti gli elementi dell'insieme menzionati nella raccolta data. Questo metodo restituisce true se questo set è cambiato come risultato della chiamata. |
| misurare() | Questo metodo viene utilizzato per ottenere la dimensione del set. Ciò restituisce un valore intero che indica il numero di elementi. |
| toArray() | Questo metodo viene utilizzato per formare un array degli stessi elementi di quello del Set. |
| toArray(T[] a) | Restituisce un array contenente tutti gli elementi di questo set; il tipo di runtime dell'array restituito è quello dell'array specificato. |
Metodi dichiarati nell'interfaccia java.util.Collection
| Metodo | Descrizione |
|---|---|
| parallelStream() | Restituisce uno Stream possibilmente parallelo con questa raccolta come origine. |
| rimuoviSe(Predicatofiltro) | Rimuove tutti gli elementi di questa raccolta che soddisfano il predicato specificato. |
| flusso() | Restituisce uno stream sequenziale con questa raccolta come origine. |
| toArray?(IntFunction | Restituisce un array contenente tutti gli elementi di questa raccolta utilizzando la funzione generatrice fornita per allocare l'array restituito. |
Metodi dichiarati nell'interfaccia java.lang.Iterable
| Metodo | Descrizione |
|---|---|
| perEach(Consumatoreazione) | Esegue l'azione specificata per ciascun elemento dell'Iterable fino a quando tutti gli elementi non sono stati elaborati o l'azione genera un'eccezione. |