Leçons

Dans ce cours, nous expliquons comment écrire vos propres collecteurs pour le Stream API via Collector et quand cela est réellement justifié, ainsi que comment implémenter votre propre Spliterator pour un parcours des données efficace, séquentiel et parallèle. Nous examinerons pas à pas les composants d’un collector ( supplier, accumulator, combiner, finisher, characteristics), des exemples pour des multi-maps et le top‑N, les stratégies trySplit, ainsi que le réglage correct des caractéristiques ( ORDERED, SIZED, SUBSIZED, etc.).

Dans ce cours, nous étudions les collections immuables de Java 9+ : les méthodes de fabrique List.of, Set.of, Map.of et Map.ofEntries. Nous les comparons aux wrappers Collections.unmodifiableList, abordons les limitations (interdiction des modifications, interdiction de null, interdiction des doublons pour les ensembles et les clés de la map), l’ordre des éléments et les performances. Nous examinons la limite de 10 paires pour Map.of et les exceptions typiques : UnsupportedOperationException, NullPointerException, IllegalArgumentException. En plus, des exemples pratiques montrant quand ces collections simplifient le design et améliorent la sécurité de lecture multi‑thread.

Dans ce cours, nous examinons les copies immuables de collections apparues avec Java 10 : List.copyOf, Set.copyOf et Map.copyOf. Vous verrez en quoi elles diffèrent des wrappers Collections.unmodifiable*, quelles contraintes s’appliquent (interdiction de null, immuabilité), quand le même objet est renvoyé et pourquoi il ne faut pas se fier à une implémentation concrète. Des scénarios pratiques d’utilisation et des erreurs typiques sont présentés, y compris la confusion avec Map.of et Map.ofEntries.

Dans ce cours, nous examinons deux approches pour « protéger » les collections : les enveloppes non modifiables de Collections.unmodifiable* et les méthodes usine List.of/ Set.of/ Map.of, ainsi que les CopyOnWriteArrayList et CopyOnWriteArraySet sûres pour les threads du paquet java.util.concurrent. Nous verrons en quoi une enveloppe diffère d’une véritable immuabilité, où les structures CopyOnWrite sont utiles, et quelles erreurs typiques apparaissent en pratique.

Dans ce cours, nous expliquons les différences entre les collections mutables et immuables en Java : quand choisir ArrayList/ HashSet et quand préférer les collections factory de Java 9+ ( List.of, Set.of, Map.of) ainsi que les copies via copyOf. Nous parlerons de sécurité, de thread-safety, de facilité de débogage, des pièges des wrappers Collections.unmodifiableList, d’exemples pratiques d’utilisation, ainsi que des erreurs courantes et des façons de les éviter.

Avec Java 21, de nouvelles interfaces de collections ordonnées sont apparues — SequencedCollection, SequencedSet et SequencedMap. Elles apportent un contrat unifié pour gérer l’ordre des éléments : accès rapide au premier/dernier élément et inversion de la collection via reversed(). Dans ce cours, nous verrons quelles collections standard les implémentent déjà, quelles méthodes sont désormais disponibles, comment les utiliser dans du code réel, ainsi que les erreurs typiques et les subtilités d’utilisation.

Cette leçon — un guide concis de l’évolution des E/S de fichiers en Java : du paquet « classique » java.io avec les classes File, les flux FileInputStream/ FileOutputStream et les lecteurs/écrivains Reader/ Writer vers le moderne java.nio.file (NIO.2) avec Path, Files et FileSystem. Nous verrons en quoi les approches diffèrent, où les E/S asynchrones l’emportent, comment migrer en toute sécurité ( File . toPath() ⇄ Path . toFile()), ainsi que des exemples pratiques, une aide‑mémoire pour le choix de l’API et les erreurs typiques.

Dans ce cours, nous examinons trois entités clés de l’API de fichiers Java : l’historique File, l’abstraction moderne de chemin Path de NIO.2 et la classe utilitaire « couteau suisse » Files. En pratique, nous verrons comment créer des objets, convertir File ↔ Path, « concaténer » des chemins en toute sécurité via resolve, obtenir des chemins relatifs via relativize, les normaliser avec normalize et effectuer des opérations comme Files.exists, Files.copy, Files.move, Files.readAllLines/ Files.write. Au final — une compréhension claire de quand utiliser chaque approche et quelles erreurs surviennent le plus souvent.

Dans ce cours, nous voyons des moyens rapides de travailler avec des fichiers via les utilitaires java.nio.file.Files : lire un fichier en entier ( readAllBytes, readAllLines) et écrire des données ( write) avec un encodage explicite StandardCharsets.UTF_8. Nous aborderons la gestion des exceptions IOException, montrerons des exemples pratiques, verrons quand utiliser les API orientées flux ( BufferedReader, BufferedWriter) et passerons en revue les erreurs typiques.

Dans ce cours, nous examinons les modes d’utilisation des fichiers en Java : réécriture et ajout, combinaisons d’options StandardOpenOption (par exemple, APPEND, CREATE, TRUNCATE_EXISTING, CREATE_NEW), le travail avec du texte et des octets via Files.write()/ Files.readAllBytes(), quand choisir les flux ( BufferedReader/ BufferedWriter) et comment gérer correctement les exceptions ( IOException, etc.). De nombreux exemples pratiques et une analyse des erreurs typiques.

Cours pratique sur la manipulation du système de fichiers via java.nio.file : nous créons des répertoires avec Files.createDirectory et Files.createDirectories, nous supprimons avec Files.delete et Files.deleteIfExists, nous listons le contenu avec Files.list, et nous abordons la suppression récursive avec Files.walkFileTree. Des exemples pas à pas, un mini‑gestionnaire de fichiers et une section sur les erreurs courantes vous aideront à travailler en toute confiance avec les dossiers sur n’importe quel système d’exploitation.

Pourquoi « lire et écrire à la cuillère à café » coûte cher : voyons comment la mise en mémoire tampon accélère l’E/S texte en Java. Nous verrons comment BufferedReader et BufferedWriter fonctionnent au‑dessus de FileReader/ FileWriter, utiliserons la lecture ligne par ligne via readLine(), l’écriture et le saut de ligne via write()/ newLine(), la vidange forcée flush(), définirons la taille du tampon et clarifierons les encodages via InputStreamReader/ OutputStreamWriter. Quand appliquer la mise en mémoire tampon, quand s’en passer — et quelles erreurs sont les plus fréquentes.