Leçons

Dans ce cours, nous abordons la lecture ligne par ligne avec BufferedReader et la lecture complète via Files.readAllLines/ Files.readString, le choix du tampon (par exemple, 8192 octets), la fermeture sûre des ressources avec try-with-resources, ainsi que la gestion des encodages ( StandardCharsets.UTF_8). Des exemples pratiques sont présentés (comptage des lignes, recherche dans un journal, analyse de configuration) et des erreurs typiques (par exemple, OutOfMemoryError lors du chargement de gros fichiers en entier).

Nous expliquons la différence entre fichiers texte et binaires, les flux d’octets de base InputStream/ OutputStream et leurs implémentations pour fichiers ( FileInputStream, FileOutputStream). Nous écrivons une copie avec tampon, discutons de la vitesse de lecture octet par octet vs par blocs, de l’écriture de tableaux d’octets via write(), des nuances de try-with-resources, du choix de la taille du tampon 4– 16 Ko, de l’utilisation sûre de readAllBytes() et des erreurs typiques (par exemple, utiliser FileReader/ FileWriter pour des données binaires).

Dans ce cours, nous abordons l’E/S binaire en Java à l’aide de DataInputStream et DataOutputStream : comment écrire et lire des types primitifs ( int, double, boolean) et des chaînes ( String) avec les méthodes writeXXX/ readXXX, pourquoi l’ordre est important, comment stocker des tableaux, quand il est pertinent d’ajouter BufferedInputStream/ BufferedOutputStream et quelles erreurs typiques mènent à IOException ou EOFException.

Nous passons en revue une manière moderne et sûre de gérer des ressources en Java — try-with-resources : comparaison avec l’ancien pattern try/ catch/ finally + close(), exigences pour les types (implémentant AutoCloseable ou Closeable), syntaxe try(...){...}, ordre de fermeture, exceptions « supprimées » via getSuppressed(), exemples avec les flux d’E/S et des ressources personnalisées, ainsi que des conseils et des erreurs courantes.

Nous expliquons ce qu’est un encodage et pourquoi, sans lui, les textes informatiques se transforment en « caractères illisibles ». Nous comparons des jeux populaires : UTF-8, Windows-1251, ASCII, Unicode/ UTF-16. Nous abordons la représentation interne des chaînes dans la JVM ( String en Unicode) et les bonnes pratiques d’entrée/sortie : préciser explicitement l’encodage via InputStreamReader/ OutputStreamWriter et StandardCharsets.UTF_8. Pour finir — exemples pratiques et erreurs typiques.

Nous analysons trois encodages de base auxquels un développeur Java est confronté : qu’est-ce que UTF-8 (le standard pour le Web et la plupart des formats), comment est organisé le format interne des chaînes dans la JVM — UTF-16 (avec paires de substitution et BOM), et pourquoi ISO-8859-1 se rencontre encore. Nous expliquons la compatibilité avec ASCII, la taille en octets par caractère, et montrons la bonne manière de travailler avec les encodages en Java à l’aide de StandardCharsets, Files.write, Files.readString, Paths.get. Pour finir — erreurs typiques : lecture/écriture incorrectes, encodage système « par défaut », confusion entre UTF-16/ UTF-8.

Comment éviter les «caractères illisibles» et faire en sorte que le texte apparaisse de la même manière sur toutes les machines : nous passons en revue l’encodage système ( "file.encoding"), le travail avec Charset et les constantes StandardCharsets, la lecture/écriture via Files . newBufferedReader et Files . newBufferedWriter, l’utilisation de try-with-resources, l’exploration des encodages disponibles et les bonnes pratiques (par défaut — "UTF-8"). Pour finir — les erreurs typiques et comment les éviter.

Dans cette leçon, nous abordons les « mojibake » (caractères illisibles), la perte de caractères ( ?), des exceptions comme MalformedInputException, les causes (mauvais appariement Windows-1251/ UTF-8, encodage système « par défaut », BOM), le diagnostic ( file.encoding) et les bonnes pratiques : indiquer explicitement le Charset, utiliser Files/ BufferedReader avec StandardCharsets, éviter FileReader/ FileWriter, ainsi que les nuances pour XML/ JSON et le BOM.

Comment lire correctement du texte depuis un fichier dans un encodage et l’écrire dans un autre à l’aide des classes java.nio.file et java.io : utiliser Files.newBufferedReader/ Files.newBufferedWriter ou InputStreamReader/ OutputStreamWriter, indiquer le Charset approprié, appliquer try-with-resources et éviter les pièges de l’encodage système. Algorithme pas à pas, exemple Windows-1251 → UTF-8, nuances (BOM, gros fichiers, exceptions) et erreurs courantes.

Comment est organisée la hiérarchie des exceptions d’E/S en Java, quelle est la différence entre IOException et son sous-type FileNotFoundException, quand elles surviennent et comment bien les gérer. Nous verrons l’ordre des blocs catch, la pratique de lecture/écriture de fichiers, des conseils de journalisation, ainsi qu’un tableau récapitulatif des erreurs les plus courantes. Nous aborderons les exceptions vérifiées (checked), les mots-clés try, catch, finally, throws et l’approche try-with-resources.

Comment vérifier en Java si un fichier ou un dossier existe : la classe File avec ses méthodes exists(), isFile(), isDirectory(), et l’approche moderne NIO via Path et Files — Files.exists(), Files.isRegularFile(), Files.isDirectory(). Nous parlerons du problème TOCTOU et pourquoi une vérification ne remplace pas la gestion des erreurs : même après exists(), vous pouvez obtenir une FileNotFoundException ou une AccessDeniedException, donc utilisez toujours des blocs try et, si possible, try-with-resources. En plus, de la pratique : lecture du fichier s’il est présent, création d’un répertoire via Files.createDirectory() et Files.createDirectories(), travail avec des chemins relatifs et absolus.

Comment reconnaître les fichiers « corrompus » à partir des exceptions ( EOFException, MalformedInputException, ZipException, StreamCorruptedException), que faire en cas de non-conformité de format, et quelles stratégies de récupération utiliser : journalisation et information de l’utilisateur, lecture partielle jusqu’à l’erreur, sauvegardes, sommes de contrôle ( SHA-256). Mise en pratique avec la lecture jusqu’à EOF, gestion correcte des encodages et analyse des erreurs typiques (validation, try-with-resources, réécriture prudente).