Leçons

Cette leçon explique ce qu’est un « goulet d’étranglement » en entrée/sortie et comment le détecter et le corriger. Nous verrons pourquoi les opérations disque et réseau sont nettement plus lentes que la RAM, quels anti‑patterns sont fréquents (lecture octet par octet via read(), journalisation synchrone, etc.), comment les tampons aident ( BufferedInputStream, BufferedReader), ainsi que les profileurs ( VisualVM, JProfiler) et la mesure du temps via System. currentTimeMillis (). Nous mènerons une expérience pratique avec la lecture du fichier "bigfile.txt", comparerons la vitesse avec et sans tampon, examinerons l’influence des SSD/HDD et du réseau, et listerons les erreurs typiques.

Introduction pratique aux E/S non bloquantes de Java NIO : nous examinons en quoi les canaux Channel et les tampons ByteBuffer diffèrent des flux InputStream/ OutputStream, comment lire et écrire avec FileChannel, se positionner via position()/ truncate(), travailler avec les paramètres du tampon ( capacity, limit, position, mark) et choisir entre allocate() et allocateDirect(). Les opérations zero-copy transferTo()/ transferFrom() sont présentées ainsi que les erreurs typiques comme l’oubli de flip() et un mode de tampon incorrect.

Comment traiter efficacement des fichiers de plusieurs dizaines de gigaoctets sans OutOfMemoryError : on les découpe en morceaux (chunks), on lit par positions via RandomAccessFile et FileChannel, on parallélise les tâches avec ExecutorService/ ForkJoinPool, et pour une copie simple on utilise le zero-copy via transferTo/ transferFrom. Nous abordons le choix de la taille de chunk, les frontières de lignes, la synchronisation des résultats et les erreurs typiques.

Comment traiter en toute sécurité et rapidement des fichiers énormes en Java : lecture par morceaux (chunking) via des flux et des tampons, réglage de la taille du tampon pour la performance, utilisation du mappage en mémoire via MappedByteBuffer et FileChannel pour un accès aléatoire ultra-rapide. Nous analyserons les avantages et inconvénients du memory mapping, des recommandations sur la gestion des ressources et le parallélisme, ainsi que les erreurs typiques (par exemple, OutOfMemoryError, descripteurs laissés ouverts, chevauchement des chunks lors d’une recherche).

Leçon pratique sur la manipulation d’archives et la compression en Java : découverte du paquet java.util.zip, des flux ZipInputStream/ ZipOutputStream et de la classe d’accès aléatoire ZipFile, gestion des niveaux de compression via Deflater ( 0… 9, DEFAULT_COMPRESSION), travail avec GZIPInputStream/ GZIPOutputStream pour des fichiers uniques, empaquetage/dépaquetage de répertoires à l’aide de Files.walk et filtrage avec PathMatcher ( "glob:**/*.txt"). Nous parlerons sécurité : protection contre le Zip Slip via la normalisation des chemins et contrôle du volume pour les zip bombs, et nous construirons un mini-CLI « zip/unzip » avec des masques.

Pourquoi et comment « emballer » des objets en Java : les transformer en flux d’octets et inversement à l’aide de ObjectOutputStream/ ObjectInputStream, conserver l’état entre les lancements, les transmettre sur le réseau et mettre en cache les résultats. Nous examinons le rôle de l’interface Serializable, les subtilités du mot‑clé transient et des chaînes comme "save.dat", et nous discutons des risques de sécurité ainsi que de la compatibilité des versions. Pratique : mini‑sauvegarde de jeu, envoi de messages client↔serveur et mise en cache des calculs.

Nous analysons les bases de la sérialisation en Java : l’interface marqueur java.io.Serializable, comment marquer une classe avec implements Serializable, les exigences pour les champs ( static, transient), des exemples pas à pas d’écriture et de lecture d’objets avec ObjectOutputStream/ ObjectInputStream, ce qui se passe « sous le capot » lors des appels à writeObject/ readObject, ainsi que les erreurs typiques (champs non sérialisables, classes internes, comportement des champs static et versions de classe via serialVersionUID).

Dans ce cours, nous comparerons la sérialisation binaire de Java via les classes ObjectOutputStream et ObjectInputStream aux formats texte ( JSON, XML) : principe de fonctionnement, vitesse et compacité, compatibilité des versions et sécurité. Nous analyserons les avantages et les limites, montrerons la pratique avec Jackson (y compris la dépendance Maven) et donnerons des conseils sur le choix à faire, ainsi que les erreurs typiques.

Dans cette leçon, nous expliquons comment sérialiser et désérialiser des objets en Java à l’aide de la paire de flux ObjectOutputStream et ObjectInputStream : ce qu’est une interface marqueur java.io.Serializable, comment fonctionnent les méthodes writeObject() et readObject(), pourquoi les champs static et transient ne sont pas écrits dans le flux, quelles exceptions peuvent survenir ( NotSerializableException, InvalidClassException), et à quoi sert serialVersionUID. En pratique, nous sérialisons un objet et une liste d’objets dans un fichier et passons en revue les erreurs typiques.

Guide pratique de la sérialisation des collections en Java : comment enregistrer et restaurer List, Map, Set via ObjectOutputStream/ ObjectInputStream ; pourquoi la plupart des collections implémentent déjà Serializable ; exigences concernant les éléments ; comportement de l’ordre dans HashSet/ HashMap ; travail avec des collections imbriquées et vides ; pièges ( InvalidClassException, serialVersionUID, transient/ static). Nous terminons par un exemple complet de « bibliothèque virtuelle ».

Comment intercepter la sérialisation standard et reprendre la main sur le processus : utiliser les méthodes privées writeObject/ readObject avec des signatures strictes ( private void writeObject( ObjectOutputStream out) throws IOException), appeler defaultWriteObject()/ defaultReadObject(), exclure des champs via transient, ajouter des sommes de contrôle et des logs, ne pas oublier serialVersionUID et la compatibilité des versions. Nous passons en revue les erreurs typiques, le travail avec ObjectOutputStream/ ObjectInputStream et des exemples pratiques.

Guide pratique de la sérialisation en Java : quand et comment utiliser transient pour exclure des champs du flux, ce qui se passe lors de la désérialisation (valeurs par défaut), comment restaurer l’état dans la méthode readObject ; ce qu’est serialVersionUID, comment le déclarer ( private static final long serialVersionUID = 1L), quand le modifier et pourquoi il vaut mieux le définir explicitement. Des exemples fonctionnels, des scénarios risqués et des erreurs typiques sont présentés.