6. Interface NavigableSet

6.1. Notion de NavigableSet

L'interface NavigableSet est une extension de SortedSet, introduite en Java 6. La classe d'implémentation fournie en standard est la même que pour SortedSet : il s'agit de TreeSet. Elle ne modifie pas la sémantique définie pour SortedSet, mais ajoute des méthodes et des fonctionnalités.

6.2. Détails des méthodes disponibles

Cette interface ajoute les méthodes suivantes à SortedSet.
  • iterator() et descendingIterator() : retournent deux itérateurs, qui permettent de balayer les objets de cet ensemble dans l'ordre croissant et décroissant, respectivement.
  • ceiling(T t) et floor(T t) : retournent le plus petit élément égal ou plus grand que l'élément passé en paramètre, et le plus grand élément égal ou plus petit que celui passé en paramètre, respectivement.
  • higher(T t) et lower(T t) : retournent le plus petit élément strictement plus grand que l'élément passé en paramètre, et le plus grand élément strictement plus petit que celui passé en paramètre, respectivement.
  • headSet(T sup, boolean inclusive) et tailSet(T inf, boolean inclusive) : retournent un NavigableSet contenant les éléments plus petits (respectivement plus grands) que l'élément passé en paramètre, inclus ou non, suivant la valeur du booléen inclusive. Encore une fois, ce sous-ensemble est une vue de l'ensemble maître.
  • subSet(T inf, boolean infInclusive ,T sup, boolean supInclusive) : retourne un NavigableSet contenant les éléments plus grands que inf et plus petits que sup. L'inclusion ou non des bornes est précisée par les deux booléens passés en paramètre.
  • pollFirst() et pollLast() retirent de l'ensemble sa plus petite valeur, ou sa plus grande respectivement, et la retournent.

6.3. Exemple d'utilisation

L'exemple présenté ici utilise la classe Marin de la partie précédente. L'ensemble est initialisé avec la même classe anonyme Comparator.

Exemple 12. Utilisation de NavigableSet 

// dans une méthode main
NavigableSet<Marin> set =  new TreeSet<Marin>(/* ici notre objet Comparator */) ;

 // initialisation de l'ensemble
Marin m1 =  new Marin("Surcouf",  "Alain") ;
Marin m2 =  new Marin("Tabarly",  "Eric") ;
Marin m3 =  new Marin("Auguin",  "Christophe") ;
Marin m4 =  new Marin("Surcouf",  "Robert") ;

set.add(m1) ;
set.add(m2) ;
set.add(m3) ;
set.add(m3) ;
set.add(m4) ;

 // vérificationd de son contenu
 for (Marin m : set) {
   System.out.println(m) ;
}

 // création d'un sous-ensemble
NavigableSet<Marin> head = set.headSet(m1, true) ;
System.out.println("Sous-ensemble head : " + head.size()) ;

 // on retire le plus petit élément de l'ensemble maître
set.pollFirst() ;
 // on constate que le sous-ensemble voit cet effacement
System.out.println("Sous-ensemble head : " + head.size()) ;

 // on efface le sous-ensemble
head.clear() ;
 // on constate que l'ensemble maître voir cet effacement
System.out.println("Ensemble set : " + set.size()) ;

Ce code affiche le résultat suivant. 
Auguin Christophe
Surcouf Alain
Surcouf Robert
Tabarly Eric
Sous-ensemble head : 2
Sous-ensemble head : 1
Ensemble set : 2
Java API avancées
Retour au blog Java le soir
Cours & Tutoriaux
Table des matières
API Collection
1. Introduction
2. Interface Collection
2.1. Notion de Collection
2.2. Détail des méthodes disponibles
2.3. Interface Iterator
2.4. Implémentation, exemples d'utilisation
3. Interface List
3.1. Notion de List
3.2. Détail des méthodes disponibles
3.3. Interface ListIterator
3.4. Implémentations, exemples d'utilisation
4. Interface Set
4.1. Notion de Set
4.2. Implémentations HashSet et LinkedHashSet
4.3. Exemples d'utilisation
5. Interface SortedSet
5.1. Notion de SortedSet
5.2. Détails des méthodes disponibles
5.3. Exemples d'utilisation
6. Interface NavigableSet
6.1. Notion de NavigableSet
6.2. Détails des méthodes disponibles
6.3. Exemple d'utilisation
7. Interfaces Queue et Deque
7.1. Notion de file d'attente
7.2. Détail des méthodes disponibles
7.3. Utilisation des interfaces Queue et Deque
8. Tables de hachage
8.1. Notion de table de hachage
8.2. Interface Map
8.3. Interface Map.Entry
8.4. Interface SortedMap
8.5. Interface NavigableMap
8.6. Implémentations
8.7. Exemples d'utilisation
9. Classes utilitaires Collections et Arrays
9.1. Introduction
9.2. Classe Arrays
9.3. Classe Collections
Génériques
1. Introduction
2. Un premier exemple
2.1. Une première classe générique
2.2. Une première méthode générique
3. Contraindre un type générique
3.1. Problème posé
3.2. Contraindre un type générique
4. Implémentation des génériques
4.1. Type erasure
4.2. Types génériques et casts
4.3. Type générique et exception
4.4. Construction d'une instance générique
4.5. Génériques et membres statiques
4.6. Collisions de méthodes génériques
4.7. Implémentation de plusieurs types identiques
5. Type <?>
5.1. Introduction
5.2. Type ? extension d'un type
5.3. Type ? super-type d'un type
Expressions régulières
1. Introduction
2. Mise en œuvre des expressions régulières
2.1. Fonctionnement d'une regexp
2.2. Fonctionnement de l'API en Java
2.3. Un premier exemple
2.4. Classe Pattern
2.5. Classe Matcher
2.6. Utilisation des méthode find() et group()
2.7. Méthodes de remplacement
2.8. Sélection de régions
3. Syntaxe des expressions régulières
3.1. Notion de classe
3.2. Étude d'un cas réel
3.3. Recherche d'un mot précis
3.4. Recherche de deux mots précis
3.5. Recherche d'un mot commençant par une lettre donnée
3.6. Cas de mots comportant des caractères accentués
3.7. Recherche sur les lignes
Introspection
1. Introduction
2. La classe Class
2.1. Utilisation de Class
2.2. Méthodes disponibles
2.3. Remarque sur la propriété Accessible
2.4. Type d'une classe
2.5. Création d'une instance à partir d'un objet Class
2.6. Cas des énumérations
3. Les classes Method et Constructor
3.1. Utilisation de Method
3.2. Utilisation de Constructor
3.3. Méthodes disponibles
3.4. Invocation d'une méthode par introspection
4. La classe Field
4.1. Utilisation de Field
4.2. Méthodes disponibles
4.3. Accès à un champ par introspection
5. La classe Modifier
Programmation concurrente
1. Introduction
2. Lançons nos premiers threads
2.1. Introduction
2.2. Un premier thread, extension de Thread
2.3. Un deuxième thread, implémentation de Runnable
2.4. Remarque sur la méthode Thread.sleep(long)
2.5. Arrêter un thread
3. Concurrence d'accès
3.1. Notion d'état
3.2. Exemple de concurrence d'accès sur un état
3.3. Analyse de la concurrence d'accès
3.4. Solution au problème
3.5. Champs volatile
4. Synchronisation
4.1. Définition d'un bloc synchronisé
4.2. Fonctionnement d'un bloc synchronisé
4.3. Notion de deadlock
4.4. Bonnes pratiques pour la synchronisation de threads
5. Opérations atomiques
5.1. Atomicité d'une opération
5.2. Solutions disponibles
5.3. Variables atomiques
6. Collections synchronisées et concurrentes
6.1. Introduction
6.2. Position du problème
6.3. Solutions proposées
7. Files d'attente
7.1. Introduction, pattern producteur / consommateur
7.2. Interface BlockingQueue<E>
7.3. Implémentations de BlockingQueue
7.4. Exemple de producteur / consommateur
7.5. Arrêter un producteur / consommateur : pilule empoisonnée
8. Classes utilitaires de l'API Concurrent
8.1. Introduction
8.2. Énumération TimeUnit
8.3. Interface Callable<V>
8.4. Interfaces Future<V> et RunnableFuture<V>
8.5. Interface ScheduledFuture<V> et RunnableScheduledFuture<V>
9. Pattern executor
9.1. Notion de réserve de threads
9.2. Interface Executor
9.3. Interface ExecutorService
9.4. Interface ScheduledExecutorService
9.5. Classe Executors
9.6. Pattern de lancement de tâches
10. Classes de contrôle d'accès
10.1. Introduction
10.2. Interfaces Lock et ReadWriteLock
10.3. Notion de verrou réentrant
10.4. Classe RentrantLock
10.5. Classe ReadWriteRentrantLock
11. Sémaphores, barrières et latches
11.1. Introduction
11.2. Notion de sémaphore, classe Semaphore
11.3. Notion de latch, classe CountDownLatch
11.4. Notion de barrière, classe CyclicBarrier