Revision sheet: Gestion des flux en Java

📋 Plan du Cours

1. Flux en Java
2. Types de flux
3. Classes java.io
4. Flux tampon
5. Lecture fichiers Java
6. Écriture fichiers Java
7. Classe Scanner Java
8. Gestion fin fichier
9. Entrée/sortie standard Java
10. Objets Serialization Java

📖 1. Flux en Java

🔑 Notions clés & Définitions

• Flux (stream) : Canal de communication permettant le transfert de données entre une source et une destination. Il représente un objet dans lequel circulent des données sous forme d'octets ou de caractères. AUTEUR (date) : « Un flux (stream) représente un canal de communication » (source).
• Flux en entrée (lecture) : Flux utilisé pour recevoir des données depuis une source externe, comme un fichier, la mémoire ou l'utilisateur. Il permet de lire des octets ou des caractères.
• Flux en sortie (écriture) : Flux destiné à envoyer des données vers une destination externe, comme un fichier ou la console. Il permet d’écrire des octets ou des caractères.
• Étapes de gestion d’un flux : Comprennent l’ouverture du flux, la lecture ou l’écriture des données, puis la fermeture du flux pour libérer les ressources.
• Codage des caractères en Unicode : Les flux traitent les caractères codés sur 2 octets, permettant la représentation universelle des caractères.

📝 Points essentiels

• Un flux en Java sert de médiateur entre la source (fichier, mémoire, utilisateur) et la programme, facilitant l’échange de données.
• La gestion d’un flux suit généralement trois étapes : ouverture, lecture/écriture, fermeture. La fermeture est essentielle pour libérer les ressources système.
• Les flux peuvent traiter des données sous forme d’octets (flux binaires) ou de caractères (flux textes). Les classes principales pour les flux binaires sont InputStream et OutputStream, tandis que pour les flux textes, ce sont Reader et Writer.
• Le codage Unicode sur 2 octets est standard pour représenter tous les caractères, assurant une compatibilité internationale.
• Les flux peuvent utiliser un tampon (buffer) pour améliorer les performances lors du traitement par lots, notamment avec les classes BufferedReader et BufferedWriter.
• Les flux automatiques System.in, System.out et System.err sont fournis par le package java.lang.System pour la gestion de l'entrée standard, la sortie standard et la sortie d’erreur.
• La classe java.io.File représente un fichier dans le système de fichiers et permet de créer des flux pour la lecture ou l’écriture dans ce fichier.

💡 À retenir

Un flux en Java est un canal de communication permettant de transférer des données entre le programme et une source ou destination externe, en suivant un cycle d’ouverture, de traitement et de fermeture, avec un codage standard en Unicode sur 2 octets.

📖 2. Types de flux

🔑 Notions clés & Définitions

• Flux binaires (octets) : Classes InputStream et OutputStream gèrent le transfert de données sous forme d’octets, permettant la lecture et l’écriture de fichiers ou flux de données brutes sans traitement de caractères.
• Flux textes (caractères) : Classes Reader et Writer manipulent des données sous forme de caractères, facilitant la lecture et l’écriture de texte en tenant compte du codage (ex : Unicode).
• Flux d'entrée (InputStream, Reader) : Canaux de communication permettant de recevoir des données dans un programme Java, comme System.in (entrée standard) ou un flux depuis un fichier.
• Flux de sortie (OutputStream, Writer) : Canaux de communication permettant d’envoyer des données depuis un programme Java, comme System.out ou un flux vers un fichier.
• Flux automatiques System.in, System.out, System.err : Flux prédéfinis dans java.lang.System pour la lecture clavier, l’affichage écran, et la gestion des erreurs, respectivement.

📝 Points essentiels

• Un flux représente un canal de communication dans lequel circulent des données, pouvant être en octets ou en caractères, selon le type de flux.
• Les flux peuvent être en entrée (lecture) ou en sortie (écriture), et peuvent utiliser un tampon (buffer) pour améliorer les performances lors du traitement par lots.
• La classe System fournit trois flux automatiques : System.in (entrée standard), System.out (sortie standard), et System.err (flux d’erreur).
• Le package java.io regroupe la majorité des classes de gestion des flux, notamment InputStream, OutputStream, Reader, et Writer.
• Différents types de flux sont utilisés selon l’origine ou la destination : tampon, fichier, tableau, tube.
• Les flux tampon, comme BufferedInputStream ou BufferedWriter, améliorent la performance en réduisant le nombre d’opérations d’entrée/sortie en traitant les données par blocs.
• La lecture d’un octet ou d’un caractère peut se faire via des méthodes spécifiques, par exemple readLine() dans BufferedReader pour lire une ligne de texte.
• La gestion des flux sur fichiers implique la création d’un objet File (package java.io) et l’utilisation de classes adaptées comme FileInputStream ou FileReader.
• La classe Scanner offre une autre méthode de lecture, notamment sur l’entrée standard ou dans des fichiers, en découpant le contenu en tokens selon des délimiteurs.

💡 À retenir

Les flux en Java sont des canaux de communication essentiels permettant de gérer l’entrée et la sortie de données sous forme d’octets ou de caractères, avec des classes spécifiques pour optimiser leur traitement selon la source ou la destination.

📖 3. Classes java.io

🔑 Notions clés & Définitions

• Paquetage java.io : Contient toutes les classes relatives à la gestion des flux d'entrée/sortie en Java, permettant de créer, manipuler et gérer des flux pour diverses sources et destinations de données.
• InputStream et OutputStream : Classes principales pour les flux binaires (octets). InputStream pour la lecture, OutputStream pour l'écriture. Exemple : ByteArrayOutputStream (écriture dans un tableau d'octets), BufferedInputStream (tampon pour lecture efficace).
• Reader et Writer : Classes principales pour les flux de caractères (texte). Reader pour la lecture, Writer pour l'écriture. Exemple : BufferedWriter (tampon pour écriture efficace), FileReader (lecture à partir d’un fichier).
• File : Classe représentant un fichier ou un répertoire dans le système de fichiers, construite à partir du chemin d’accès. Elle sert à manipuler les fichiers (création, suppression, vérification).
• Nommage des classes : Selon leur origine ou destination (tampon, fichier, tableau, tube), leur sens (lecture ou écriture) et leur type (octets ou caractères). Par exemple, BufferedInputStream (tampon, octets, lecture), ByteArrayOutputStream (tableau, octets, écriture), BufferedWriter (tampon, caractères, écriture).

📝 Points essentiels

• La gestion des flux en Java repose sur la création d’objets flux connectant une source ou une destination à un programme, permettant l’échange de données sous forme d’octets ou de caractères.
• Les flux binaires (classes InputStream et OutputStream) manipulent des octets, tandis que les flux de caractères (classes Reader et Writer) gèrent le texte.
• Le paquetage java.io fournit des classes pour créer des flux spécifiques selon l’origine ou la destination : tampon, fichier, tableau, tube.
• Les classes BufferedInputStream et BufferedWriter permettent d’améliorer les performances en utilisant des tampons pour le traitement par lots.
• La classe File représente un fichier ou un répertoire, facilitant la manipulation des fichiers dans le système.
• La lecture et l’écriture dans un fichier se font via des flux spécifiques : FileInputStream / FileOutputStream pour les octets, FileReader / FileWriter pour les caractères.
• La classe Scanner (voir section 7) offre une autre méthode pour lire des données, notamment sur l’entrée standard ou dans des fichiers, en découpant les données en tokens selon des délimiteurs.
• La fin de fichier dans ObjectInputStream est détectée via la gestion d’exception EOFException (voir section 8).

💡 À retenir

Les classes du paquetage java.io permettent de gérer efficacement les flux d’entrée et de sortie en Java, en proposant des outils pour manipuler des données binaires ou textuelles, avec des options de tamponnage pour optimiser les performances.

📖 4. Flux tampon

🔑 Notions clés & Définitions

• Flux tampon (Buffered stream) : Classe qui améliore les performances d'entrée/sortie en utilisant une mémoire tampon pour traiter les données par lots, évitant ainsi les opérations d'accès fréquentes à la source ou destination.
• BufferedReader : Classe de la bibliothèque java.io permettant de lire du texte de façon tamponnée, notamment avec la méthode readLine() pour lire une ligne complète de texte.
• BufferedWriter : Classe de java.io pour écrire du texte de manière tamponnée, optimisant l'écriture en regroupant les données avant de les transférer.
• Méthode readLine() : Fonction de BufferedReader qui lit une ligne de texte jusqu’au caractère de fin de ligne, et la retourne sous forme d’un objet String, en lançant une IOException en cas d’erreur.
• Flux tampon (buffer) : Zone mémoire intermédiaire utilisée pour stocker temporairement des données lors des opérations d’entrée/sortie, permettant un traitement par lots et réduisant le nombre d’accès directs à la source ou destination.

📝 Points essentiels

• Les flux tamponnés, tels que BufferedReader et BufferedWriter, sont conçus pour améliorer significativement les performances des opérations d’entrée/sortie en regroupant les données dans un tampon mémoire.
• La méthode readLine() de BufferedReader facilite la lecture de texte ligne par ligne, ce qui est pratique pour traiter des fichiers ou des entrées utilisateur.
• Ces classes s’utilisent en complément des flux de base (par exemple, FileReader ou FileWriter) pour bénéficier de leur capacité de tamponnage.
• La gestion du tampon permet de réduire le nombre d’opérations coûteuses d’accès aux fichiers ou aux flux, en traitant par lots les données.
• La création d’un flux tamponné nécessite généralement l’instanciation d’un objet BufferedReader ou BufferedWriter en passant en paramètre un flux de base (ex : FileReader, FileWriter).
• La fermeture des flux tamponnés libère la mémoire tampon et assure la sauvegarde des données en attente.

💡 À retenir

Les flux tamponnés, via BufferedReader et BufferedWriter, optimisent les opérations d’entrée/sortie en utilisant une mémoire tampon pour traiter efficacement les données par lots, avec la méthode readLine() permettant une lecture ligne par ligne.

📖 5. Lecture fichiers Java

🔑 Notions clés & Définitions

• File (voir section 2) : Classe java.io.File permettant de représenter un fichier ou un répertoire à partir du chemin d’accès, facilitant la gestion et la manipulation des fichiers dans le système de fichiers.
• FileInputStream (voir section 1) : Classe de flux binaire (octets) permettant de lire des données brutes à partir d’un fichier, en ouvrant un flux d’entrée sur un fichier spécifique.
• FileReader (voir section 1) : Classe de flux de caractères permettant de lire du texte à partir d’un fichier, en utilisant un encodage compatible avec Unicode.
• Création d’un objet File : Opération consistant à instancier un objet java.io.File en lui passant le chemin d’accès du fichier, préalable à l’ouverture d’un flux pour lecture ou écriture.
• Gestion de l’ouverture et fermeture des flux : Processus d’initiation (ouverture) d’un flux pour accéder à un fichier, puis sa fermeture après utilisation pour libérer les ressources, souvent via try-with-resources ou méthodes close().

📝 Points essentiels

• La lecture de fichiers en Java s’appuie sur la création d’un objet File à partir du chemin d’accès, qui sert de référence pour ouvrir un flux spécifique (ex : FileInputStream pour les octets, FileReader pour les caractères).
• FileInputStream permet la lecture binaire (octets) du contenu d’un fichier, tandis que FileReader facilite la lecture de caractères, notamment pour du texte en Unicode.
• La gestion correcte de l’ouverture et de la fermeture des flux est cruciale pour éviter les fuites de ressources. La fermeture doit intervenir après la lecture, souvent à l’aide de la méthode close() ou via la syntaxe try-with-resources.
• La classe File ne lit pas directement le contenu, mais sert à localiser et manipuler le fichier pour ouvrir un flux associé.
• La lecture de caractères peut utiliser la méthode read() de FileReader ou BufferedReader (pour tamponner et améliorer les performances), avec la méthode readLine() pour lire une ligne complète.
• La classe System.in représente un flux d’entrée standard (clavier), accessible via InputStream (voir section 1), pour la lecture interactive.

💡 À retenir

La lecture de fichiers en Java repose sur la création d’un objet File pour localiser le fichier, puis l’ouverture d’un flux adapté (FileInputStream ou FileReader) pour accéder aux données, en assurant leur fermeture après utilisation pour préserver les ressources.

📖 6. Écriture fichiers Java

🔑 Notions clés & Définitions

• FileOutputStream : classe de java.io permettant d’écrire des octets dans un fichier, en mode binaire. Elle est utilisée pour créer un flux de sortie vers un fichier (voir section 5).
• FileWriter : classe de java.io conçue pour écrire des caractères dans un fichier, en utilisant le codage par défaut du système. Elle facilite l’écriture de texte dans un fichier (voir section 5).
• BufferedWriter : classe de java.io qui enveloppe un Writer (par exemple, FileWriter) pour ajouter un tampon d’écriture. Elle optimise les performances en réduisant le nombre d’opérations d’écriture en mémoire tampon, et offre la méthode write() et newLine() pour écrire du texte avec tamponnage (voir section 4).
• Fermeture des flux : étape essentielle pour libérer les ressources système et assurer la sauvegarde correcte des données. Elle se réalise en appelant la méthode close() sur l’objet flux après l’écriture (voir section 4).

📝 Points essentiels

• La création d’un flux d’écriture commence par l’instanciation d’un objet comme FileOutputStream ou FileWriter, en passant en paramètre un objet File ou un chemin de fichier.
• FileOutputStream est adapté pour écrire des octets, notamment en mode binaire, tandis que FileWriter est plus pratique pour écrire du texte en caractères.
• L’utilisation de BufferedWriter permet d’améliorer la performance lors de l’écriture en tamponnant les données dans une mémoire tampon, puis en les transférant en bloc vers le fichier. La méthode write() permet d’écrire une chaîne de caractères, et newLine() insère une ligne nouvelle.
• La fermeture du flux avec close() est obligatoire pour assurer la sauvegarde des données et libérer les ressources système. Elle doit être effectuée dans un bloc finally ou en utilisant un try-with-resources pour garantir son exécution même en cas d’exception.
• La gestion correcte des flux d’écriture évite la perte de données et garantit l’intégrité du fichier.

💡 À retenir

L’écriture dans un fichier en Java s’effectue via la création d’un flux d’écriture (FileOutputStream, FileWriter ou BufferedWriter), suivie de l’écriture des données, puis de la fermeture du flux pour assurer la sauvegarde et la libération des ressources. Le tamponnement avec BufferedWriter optimise la performance lors de l’écriture de texte.

📖 7. Classe Scanner Java

🔑 Notions clés & Définitions

• Classe Scanner (java.util) : classe permettant de lire et découper des flux d'entrée (standard ou fichiers) en tokens selon des délimiteurs, facilitant la lecture de différents types de données (int, double, String).
• Découpage en tokens : processus de division d'une chaîne ou d'un flux en éléments (tokens) individuels, selon un délimiteur spécifié (ex : espace, virgule).
• Lecture sur l’entrée standard : utilisation de Scanner pour lire des données saisies par l’utilisateur via le flux System.in, simplifiant la gestion des entrées clavier.
• Lecture dans un fichier : création d’un Scanner à partir d’un objet File ou d’un flux de fichier, permettant de traiter le contenu d’un fichier de façon structurée.
• Méthodes de lecture : méthodes spécifiques pour lire différents types : nextInt(), nextDouble(), nextLine(), etc., qui convertissent le token lu en le type correspondant.

📝 Points essentiels

• La classe Scanner appartient au package java.util et offre une interface simple pour lire des données depuis diverses sources, notamment l’entrée standard et les fichiers.
• Elle permet de découper automatiquement le contenu en tokens en utilisant un délimiteur (par défaut, espace blanc), grâce à la méthode useDelimiter().
• La lecture de données se fait via des méthodes spécifiques : nextInt(), nextDouble(), nextLine(), etc., qui facilitent la conversion en types primitifs ou chaînes.
• Lors de la lecture dans un fichier, un objet Scanner peut être créé à partir d’un objet File ou d’un flux de fichier (ex : FileInputStream).
• La méthode close() doit être appelée pour libérer les ressources une fois la lecture terminée.
• La fin de fichier est détectée via la gestion d’EOFException lors de la lecture avec ObjectInputStream, mais pour Scanner, il faut vérifier la présence de tokens avec hasNext() ou hasNextInt().
• La classe facilite également le découpage de chaînes de caractères en tokens, en utilisant useDelimiter() pour définir un délimiteur personnalisé.

💡 À retenir

La classe Scanner simplifie la lecture et le découpage des flux d’entrée (standard ou fichiers) en tokens, tout en permettant de lire divers types de données avec une syntaxe claire et efficace.

📖 8. Gestion fin fichier

🔑 Notions clés & Définitions

• Gestion de la fin de fichier : Processus permettant de détecter la fin d’un flux de données lors de la lecture, notamment en Java, où aucune méthode directe n’est fournie par ObjectInputStream pour cette détection.
• Absence de méthode directe dans ObjectInputStream : ObjectInputStream ne possède pas de méthode spécifique pour vérifier si la fin du fichier est atteinte, ce qui oblige à utiliser d’autres mécanismes pour gérer cette situation.
• EOFException : Exception levée en Java lorsqu’une opération de lecture dépasse la fin d’un flux ou d’un fichier, utilisée comme mécanisme pour détecter la fin de fichier dans le contexte de ObjectInputStream (voir aussi l’utilisation d’exceptions).
• Mécanisme de capture d’exception : Technique consistant à entourer la lecture d’un flux avec un bloc try-catch pour attraper EOFException et ainsi déterminer que la fin du fichier a été atteinte, permettant de contrôler la terminaison de la lecture.

📝 Points essentiels

• La classe ObjectInputStream ne fournit pas de méthode spécifique pour vérifier si la fin du fichier est atteinte, contrairement à d’autres classes de gestion des flux (voir section 1).
• La détection de la fin de fichier se fait en capturant l’EOFException qui est levée lorsqu’une tentative de lecture dépasse la dernière donnée disponible dans le flux.
• La pratique courante consiste à entourer la lecture dans un try-catch et à arrêter la lecture lorsque cette exception est attrapée, ce qui évite des erreurs non gérées et permet un contrôle précis.
• Ce mécanisme est essentiel pour la lecture sérielle d’objets avec ObjectInputStream, notamment lors de la lecture de plusieurs objets dans un fichier (voir section 10).
• La gestion de la fin de fichier par exception est une solution standard en Java, car aucune méthode native ne permet de vérifier la présence de données restantes dans le flux.

💡 À retenir

En Java, la fin d’un fichier lu avec ObjectInputStream ne peut pas être détectée directement par une méthode spécifique ; elle doit être gérée en capturant l’EOFException lors de la lecture, ce qui constitue une pratique courante pour contrôler la terminaison de flux.

📖 9. Entrée/sortie standard Java

🔑 Notions clés & Définitions

• Flux (stream) : Canal de communication permettant de transférer des données entre une source et une destination, représenté par un objet dans lequel circulent des octets ou des caractères. (source)
• System.in : Flux d'entrée standard en Java, utilisé pour la lecture clavier, fourni automatiquement par le système, de type InputStream. (java.lang.System)
• System.out : Flux de sortie standard en Java, utilisé pour afficher à l'écran, de type PrintStream, fourni automatiquement par le système. (java.lang.System)
• System.err : Flux d'erreur standard en Java, destiné à l'affichage des messages d'erreur, également de type PrintStream, fourni par le système. (java.lang.System)
• Codage Unicode : Norme de codage des caractères utilisant 2 octets par caractère, permettant la représentation de tous les caractères universels, appliquée dans les flux pour assurer la compatibilité multilingue. (source)

📝 Points essentiels

• La communication en Java s'effectue via des flux, qui peuvent être en entrée (lecture) ou en sortie (écriture). Ces flux peuvent représenter des octets (flux binaires) ou des caractères (flux textes).
• Les flux automatiques System.in, System.out et System.err sont intégrés dans le paquetage java.lang.System et facilitent la gestion des interactions avec l'utilisateur et la gestion des erreurs.
• La gestion des flux d'entrée/sortie dans Java repose sur le paquetage java.io, qui fournit des classes pour manipuler des flux de données, notamment pour la lecture et l'écriture dans des fichiers ou autres sources.
• Les flux tamponnés, comme BufferedReader et BufferedWriter, améliorent les performances en traitant les données par lots, avec la méthode readLine() permettant de lire une ligne de texte en une seule opération.
• La lecture clavier se réalise via la variable statique System.in, qui doit être convertie en flux de caractères ou octets selon le contexte d'utilisation.
• Pour la lecture ou l’écriture dans un fichier, on utilise des classes spécifiques comme FileInputStream, FileReader, FileOutputStream, FileWriter, en créant un objet File à partir du chemin d’accès.

💡 À retenir

Les flux d'entrée/sortie standard en Java, intégrés dans System (System.in, System.out, System.err), offrent une interface simple pour la communication avec l'utilisateur et la gestion des erreurs, en s'appuyant sur le paquetage java.io pour des opérations plus avancées.

📖 10. Objets Serialization Java

🔑 Notions clés & Définitions

• Sérialisation : processus de conversion d’un objet Java en un flux d’octets pour le stocker ou transmettre, permettant sa reconstruction ultérieure (désérialisation).
• ObjectInputStream / ObjectOutputStream : classes de la bibliothèque java.io utilisées pour la désérialisation et la sérialisation d’objets, respectivement. (voir section 4)
• Construction des flux de sérialisation : réalisation à partir de FileInputStream / FileOutputStream, qui eux-mêmes se construisent à partir d’un objet de type File, permettant de lire ou écrire dans un fichier. (voir section 5 et 6)
• Méthodes writeObject() / readObject() : méthodes essentielles pour écrire un objet dans un flux ou le lire à partir de celui-ci, respectivement. Ces méthodes gèrent la sérialisation et la désérialisation. (voir section 4)
• Niveaux d’abstraction dans la sérialisation : la sérialisation s’effectue à différents niveaux, notamment :
  1. La classe ObjectInputStream / ObjectOutputStream, qui gère le processus global.
  2. La construction à partir de FileInputStream / FileOutputStream.
  3. La construction à partir d’un objet File, représentant le fichier de stockage.

📝 Points essentiels

• La sérialisation permet de sauvegarder l’état d’un objet pour une utilisation ultérieure ou pour le transmettre via un réseau.
• La construction des flux de sérialisation suit une hiérarchie : File → FileInputStream / FileOutputStream → ObjectInputStream / ObjectOutputStream.
• La méthode writeObject() écrit un objet dans le flux, tandis que readObject() lit un objet depuis le flux. Ces méthodes doivent être utilisées dans un contexte où la classe de l’objet est sérialisable (implémente Serializable).
• La classe ObjectInputStream ne possède pas de méthode pour détecter directement la fin du fichier ; il faut gérer cette fin via une exception EOFException lors d’une lecture.
• La sérialisation est un mécanisme d’abstraction qui masque la complexité de la conversion d’objets en flux d’octets, en permettant une gestion simple via des méthodes spécifiques.

💡 À retenir

La sérialisation en Java, via ObjectInputStream et ObjectOutputStream, repose sur une hiérarchie de flux construits à partir de fichiers, permettant d’écrire et de lire des objets de manière abstraite et efficace, tout en gérant la fin de fichier par exceptions.

📊 Tableaux de Synthèse

⚠️ Pièges & Confusions Fréquentes

1. Confondre InputStream (octets) et Reader (caractères), notamment lors du traitement de fichiers texte.
2. Oublier de fermer un flux après utilisation, entraînant des fuites de ressources.
3. Ne pas utiliser de tampon (buffer) pour de gros volumes de données, ce qui dégrade la performance.
4. Confondre System.in (entrée standard) avec un flux de fichier, ou ne pas le gérer correctement.
5. Mal gérer la fin de fichier dans ObjectInputStream ou BufferedReader, provoquant des exceptions.
6. Utiliser File pour créer un flux sans vérifier l’existence ou les droits d’accès du fichier.
7. Confondre la lecture d’octets avec la lecture de caractères, notamment dans le traitement de fichiers binaires versus texte.

✅ Checklist Examen

• Connaître la définition d’un flux (stream) selon la source et la destination, en se référant à la source (source : source).
• Savoir différencier flux binaire (InputStream, OutputStream) et flux de caractères (Reader, Writer).
• Maîtriser le rôle des classes java.io.File et leur utilisation pour manipuler des fichiers.
• Expliquer le cycle de gestion d’un flux : ouverture, lecture/écriture, fermeture.
• Identifier les classes principales pour la lecture et l’écriture dans un fichier binaire ou texte.
• Comprendre l’utilité des classes tampon comme BufferedReader et BufferedWriter pour améliorer la performance.
• Savoir utiliser System.in, System.out, et System.err pour l’entrée/sortie standard.
• Connaître la classe Scanner et ses avantages pour la lecture de données structurées.
• Savoir gérer la fin de fichier lors de la lecture avec BufferedReader ou ObjectInputStream.
• Maîtriser la différence entre flux en octets et flux en caractères, et leur utilisation appropriée.
• Connaître la classe java.io.Serializable pour la sérialisation d’objets.
• Savoir créer et utiliser un flux pour la sérialisation et désérialisation d’objets Java.
• Connaître la définition de Perroux sur la croissance (si applicable dans le contenu).
• Vérifier la maîtrise du codage Unicode en Java et son impact sur la lecture/écriture de caractères.
• Savoir gérer les exceptions liées aux flux, notamment IOException.
• Comprendre le rôle de close() pour libérer les ressources système.
• Savoir utiliser FileInputStream et FileOutputStream pour les flux binaires.
• Maîtriser la lecture ligne par ligne avec BufferedReader et readLine().
• Vérifier la compréhension des flux automatiques System.in, System.out, System.err.
• Connaître la différence entre flux tampon et flux non tampon.
• Savoir utiliser ObjectInputStream et ObjectOutputStream pour la sérialisation d’objets.
• Vérifier la compréhension des classes Reader et Writer pour la gestion du texte.
• S’assurer de la maîtrise des concepts de flux en Java pour une gestion efficace de l’entrée/sortie.