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

L'API Collection est une des API utilitaires les plus utilisées en Java. Elle a été introduite dans la version 1.2 de Java, et a été entièrement réécrite en Java 5, pour supporter l'utilisation des génériques.

À la base de cette API se trouvent trois interfaces : Collection et Map, qui modèlisent respectivement les collections et les tables de hachage, et Iterator, qui modèlise les itérateurs que l'on peut construire sur ces objets. Ces trois interfaces sont présentes dans l'API Java depuis la version 1.2.

Une troisième interface, Iterable ne fait pas partie strictement de l'API Collection. Elle a été introduite en Java 5, lorsque le for each a été ajouté au langage. Nous allons toutefois la voir ici, car l'ensemble des éléments de l'API Collection implémente cette interface.

Enfin, quelques éléments ont été ajoutés à cette API en Java 6 : DeQue, NavigableMap et NavigableSet.

Les interfaces Collection et Map sont la base d’un ensemble d’interfaces et de classes qui ont pour but de faciliter la manipulation des ensembles structurés de données. Parmi ces ensembles, citons les listes chaînées, les listes ordonnées, les vecteurs, les tableaux, les tables de hachages.

Ces interfaces nous fournissent un ensemble de méthodes qui permettent d’accéder à ces données de façon naturelle suivant le type de structure choisie. Elles sont rangées dans le paquet java.util.

Les ensembles sont gérés par la hiérarchie qui étend l'interface Collection. De l’interface Collection, dérivent directement ou non toutes les autres. Une instance de Collection est un ensemble d’objets, non ordonné, et dans lequel on peut trouver des objets dupliqués.

L’interface Collection est étendue par l’interface List, qui ajoute la notion d’ordre à Collection. Cette liste est indexée par des entiers, l’utilisateur a donc le contrôle de l’endroit où il insère un élément. Elle est également étendue par l’interface Set, qui interdit d’avoir deux éléments identiques dans l’ensemble. Enfin, l’interface Set est étendue par l’interface SortedSet, qui ajoute la notion d’ordre à Set.

En Java 5, l'interface Queue s'ajoute aux interfaces qui étendent Collection. Cette interface modélise une file d'attente, à laquelle on peut ajouter des éléments ou en retirer.

En Java 6, s'ajoute encore l'interface DeQue ( double-ending queue ), qui étend Queue. Cette interface permet d'ajouter ou de retirer des éléments des deux côtés de la file d'attente modélisée.

Nous verrons que ces deux interfaces sont également étendues par BlockingQueue et BlockingDeque, deux files d'attente créées pour les opérations concurrentes.

Enfin, les tables de hachage sont gérées par l’interface Map, elle-même étendue par SortedMap, qui ajoute la notion d’ordre à Map.

À chacune de ces interfaces sont associées des classes concrètes qui permettent de les instancier. Toutefois, il est fortement conseillé d’associer un de ces types à ces classes concrètes, pour des raisons de compatibilité et de lisibilité.

Java API avancées
Retour au blog Java le soir
Cours & Tutoriaux