Java avancé en ligne

José Paumard


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

Liste des exemples

1. Création d'une collection de String
2. Test d'appartenance d'un objet à une collection
3. Parcourir les éléments d'une collection avec un itérateur
4. Parcourir les éléments d'une collection avec un for each
5. Conversion d'une collection en tableau
6. Création d'une liste de String
7. Utilisation du ListIterator
8. Utilisation d'un Set
9. Classe ComparableMarin
10. Utilisation de SortedSet avec des éléments Comparable
11. Utilisation de SortedSet avec un Comparator
12. Utilisation de NavigableSet
13. Utilisation d'une table de type HashMap
14. Utilisation d'une table de type TreeMap
15. Utilisation de Arrays.asList(...)
16. Utilisation de Arrays.toString()
17. Utilisation de Arrays.deepToString()
18. Classe ArrayList de Java 4
19. Classe ArrayList de Java 5
20. Un ArrayList de String
21. Instanciation d'un ArrayList générique
22. Déclaration d'une méthode générique
23. Appel d'une méthode générique
24. Première et mauvaise implémentation de getFirst(T t)
25. Seconde implémentation de getFirst(T t)
26. Contraintes multiples sur un type générique
27. Classe Holder
28. Type erasure et cast - 1
29. Type erasure et cast - 2
30. Type erasure et cast - 3
31. Utilisation illégale d'un type générique dans un catch
32. Constructions génériques illégales
33. Construction générique correcte
34. Membres statiques génériques illégaux
35. Méthode générique illégale
36. Implémentation générique illégale
37. Problème de sureté de type générique
38. Utilisation du type ? extends T
39. Utilisation du type ? super T
40. Utilisation de la méthode statique Pattern.matches
41. Comparaison par utilisation d'un Matcher
42. Découpage par la méthode matcher.split()
43. Exemple d'utilisation de find() et group()
44. Utilisation de matcher.replaceAll()
45. Utilisation de matcher.appendReplacement()
46. Exemple d'expressions régulières complexes
47. Création d'un objet par introspection
48. Utilisation de Class.isAssignableFrom(Class)
49. Introspection d'une énumération : définition de l'enum
50. Introspection d'une énumération : découvertes des valeurs constantes
51. Utilisation de invoke() : classe de test
52. Utilisation de invoke() : invocation des méthodes
53. Introspection sur un champ
54. Premier thread par extension de la classe Thread
55. Lancement d'un premier thread
56. Deuxième thread, par implémentation de Runnable
57. Lancement d'un deuxième thread
58. Interruption d'un thread
59. Accès concurrent à un état : classe Chaudiere
60. Accès concurrent à un état : classe Thermostat
61. Accès concurrent à un état : méthode main()
62. Accès concurrent à un état : code pathologique
63. Classe Thermostat corrigée
64. Déclaration d'un bloc synchronisé
65. Deadlock : classe Verre
66. Deadlock : classe Carafe
67. Deadlock : application
68. Atomicité d'une opération : classe SimpleCompteur
69. Atomicité d'une opération : utilisation de SimpleCompteur
70. Classe SimpleCompteur synchronisée
71. Classe SimpleCompteur utilisant un AtomicInteger
72. Concurrence sur une table de hachage
73. Concurrence sur une collection
74. Producteur / consommateur : la boulangerie
75. Producteur / consommateur : la classe Boulanger
76. Producteur / consommateur : la classe Mangeur
77. Producteur / consommateur : le système
78. Pilule empoisonnée : création de la pilule
79. Pilule empoisonnée : modification du consommateur
80. Pilule empoisonnée : code d'arrêt du système
81. Pilule empoisonnée : ajout de la méthode d'arrêt à la file d'attente
82. Utilisation de FutureTask<V>
83. Interface Executor
84. Lancement de tâches - pattern Executors
85. Cas de deux blocs synchronisés sur le même objet
86. Utilisation d'un RentrantLock
87. Sémaphore pour limiter la taille d'une collection
Java API avancées
Retour au blog Java le soir
Cours & Tutoriaux