
FAQ Fichiers, flux et r�seauxConsultez toutes les FAQ
Nombre d'auteurs : 15, nombre de questions : 95, derni�re mise � jour : 21 mars 2016 Ajouter une question
Cette FAQ a �t� r�alis�e � partir des questions fr�quemment pos�es sur le forum Java de http://java.developpez.com ainsi que l'exp�rience personnelle des auteurs.
Nous tenons � souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est humaine. Cette FAQ ne pr�tend pas non plus �tre compl�te. Si vous trouvez une erreur, ou que vous souhaitez nous aider en devenant r�dacteur, lisez ceci.
Sur ce, nous vous souhaitons une bonne lecture.
- Comment manipuler les entr�es et sorties ?
- Qu'est-ce qu'un flux ?
- Quels sont les principaux types de flux d�entr�e ?
- Quels sont les principaux types de flux de sortie ?
- Comment manipuler des flux de caract�res ?
- Quels sont les principaux types de readers ?
- Quels sont les principaux types de writers ?
- Comment �crire dans un fichier en acc�s direct ?
- Qu'est-ce qu'un canal ?
- Quels sont les principaux types de canaux ?
- Qu'est-ce qu'un tampon ?
- Quels sont les principaux types de tampons ?
- Comment lib�rer proprement les ressources ?
- Comment �crire des informations sur les sorties standards ?
- Comment lire des informations sur l'entr�e standard ?
- Comment rediriger les flux standards dans des fichiers ?
- Peut-on modifier l'encodage de la sortie standard ?
- Comment charger une ressource pr�sente dans le CLASSPATH ?
- Comment changer l'encodage d'un fichier texte ?
- Comment conna�tre les Charset disponibles et leurs alias ?
- Comment obtenir un canal sur un fichier ?
- Quels sont les modes d'ouverture des canaux sur des fichiers ?
- Comment cr�er un tampon en m�moire ?
- Comment lire ou �crire un fichier Little-Endian ?
- Comment lire un fichier texte ligne par ligne ?
- Comment lire les �l�ments d'un fichier en utilisant un d�limiteur appropri� ?
- Comment �crire � la fin d'un fichier ?
- Comment lire et g�n�rer des documents aux formats sp�cifiques (pdf, rtf, html, doc, etc.) ?
Dans l'API Java, vous avez quatre fa�ons distinctes, mais compl�mentaires de manipuler les entr�es sorties.
Les flux
Les flux, qui font partie de l'API Java classique, permettent de lire et d��crire des ensembles s�quentiels d'octets qui peuvent provenir de fichiers, sockets, p�riph�riques, etc. On les utilise, par exemple, pour lire et �crire des fichiers binaires (puisqu'on manipule des octets).
Les Reader et Writer
Dans l'API Java classique, ces classes sont destin�es � manipuler des flux de caract�res (des ensembles s�quentiels de caract�res) qui sont une d�rivation sp�cialis�e des flux d'octets et qui peuvent provenir de fichiers, sockets, p�riph�riques, etc. On les utilise, par exemple, pour lire et �crire des fichiers texte (puisqu'on manipule des caract�res).
La classe RandomAccessFile
Dans l'API Java classique, cette classe permet d'effectuer des op�rations de lecture/�criture en acc�s direct sur un fichier. On l'utilise g�n�ralement pour lire et �crire des fichiers binaires.
Les canaux et les tampons
Dans NIO, ces objets permettent d�effectuer des op�rations de lecture/�criture asynchrones (non bloquantes) sur des fichiers ou des sockets via des tampons m�moire. Les canaux permettent �galement de manipuler plus ais�ment des fichiers de grande taille. On les utilise g�n�ralement pour lire et �crire des fichiers binaires.
Note�: le patron de conception
d�corateur est largement utilis� par les flux, les Reader, les Writer ce qui explique le nombre important de classes disponibles dans l'API.
-
Tutoriel : Au c�ur du JDK : java.io expliqu� simplement par Olivier Croisier.
Dans l'API Java classique, un flux ou flux d�entr�e/sortie (stream, I/O stream) est une entit� qui permet de lire ou d��crire une suite s�quentielle d'octets. Les flux offrent une forme d'abstraction qui permet de manipuler des suites d'octets de mani�re unique, ind�pendante de la nature de la sortie ou de la source. On distingue les flux d�entr�e (input stream) qui permettent de lire une suite s�quentielle d'octets et les flux de sortie (output stream) qui permettent d��crire une suite s�quentielle d'octets. L'API contient plusieurs classes sp�cialis�es permettant de manipuler des flux attach�s � telle ou telle ressource ou de composer des flux entre eux (i.e.�: ByteArrayInputStream, FileInputStream, DataInputStream, etc.). La plupart des op�rations de lecture ou d��criture sur les flux sont susceptibles de g�n�rer des exceptions de type IOException en cas d'erreur.
De par leur nature, les flux sont souvent attach�s � des ressources natives (fichier, socket, etc.) qui doivent �tre lib�r�es lorsque vous avez fini d'utiliser le flux. Vous devez donc invoquer leur m�thode close() lorsque vous avez fini de les manipuler. Les flux impl�mentant l'interface AutoClosable, il est ainsi possible de les utiliser dans une construction try-with-resources qui fermera automatiquement le flux en fin de bloc.
Flux d�entr�e
Ce type de flux permet de lire de fa�on identique des octets provenant d'un fichier, d'une socket r�seau, d'un tableau d'octets en m�moire ou d'un port physique ou un p�riph�rique, etc. Ces flux h�ritent de la classe java.io.InputStream.
Par exemple, pour lire le contenu d'un fichier avec l'API Java classique, on fera�:
Code Java : | S�lectionner tout |
1 2 3 4 | try (InputStream input = new FileInputStream("fichier.txt") { // Lecture du flux. [...] } |
Et avec NIO2, on fera�:
Code Java : | S�lectionner tout |
1 2 3 4 | try (InputStream input = Files.newInputStream(Paths.get("fichier.txt")) { // Lecture du flux. [...] } |
Flux de sortie
Ce type de flux permet d��crire de fa�on identique des octets dans un fichier, une socket r�seau, un tableau d'octets en m�moire ou sur un port physique ou p�riph�rique, etc. Ces flux h�ritent de la classe java.io.OutputStream.
Par exemple, pour �crire dans un fichier avec l'API Java classique, on fera�:
Code Java : | S�lectionner tout |
1 2 3 4 | try (OutputStream output = new FileOutputStream("fichier.txt") { // �criture du flux. [...] } |
Et avec NIO2, on fera�:
Code Java : | S�lectionner tout |
1 2 3 4 | try (OutputStream output = Files.newOutputStream(Paths.get("fichier.txt")) { // �criture du flux. [...] } |
Le patron de conception
d�corateur est largement utilis� par les flux�; certaines classes sont donc destin�es � ajouter des nouveaux comportements et de nouvelles fonctionnalit�s aux flux d�entr�e de base. Voici quelques-unes des classes de flux d�entr�es que vous serez amen�s � manipuler le plus souvent�:
- javax.sound.sampled.AudioInputStream - d�core un flux d�entr�e pour permettre d'y lire du son�;
- java.io.ByteArrayInputStream - permet de manipuler un tableau d'octets (byte[]) comme un flux d�entr�e�;
- java.io.FileInputStream - permet d'ouvrir un flux d�entr�e sur un fichier�;
- java.io.FilterInputStream - classe de base pour tous les d�corateurs permettant de filtrer le contenu du flux d�entr�e�:
- java.io.BufferedInputStream - d�core un flux d�entr�e en lui associant un tampon m�moire,
- java.io.DataInputStream - d�core un flux d�entr�e de mani�re � pouvoir y lire des types Java primitifs,
- javax.swing.ProgressMonitorInputStream - d�core un flux d�entr�e de mani�re � pouvoir afficher une boite de dialogue de progression de lecture dans une interface Swing�;
- java.io.ObjectInputStream - d�core un autre flux d�entr�e pour permettre de d�s�rialiser un objet�;
- java.io.PipedInputStream - permet de connecter un flux de sortie PipedOutputStream sur un flux d�entr�e�;
- java.io.SequenceInputStream - permet d'effectuer une concat�nation logique de deux flux d�entr�e.
Le patron de conception
d�corateur est largement utilis� par les flux�; certaines classes sont donc destin�es � ajouter des nouveaux comportements et de nouvelles fonctionnalit�s aux flux de sortie de base. Voici quelques-unes des classes de flux de sortie que vous serez amen�s � manipuler le plus souvent�:
- java.io.ByteArrayOutputStream - permet de manipuler un tableau d'octets (byte[]) comme un flux de sortie�;
- java.io.FileArrayOutputStream - permet d'ouvrir un flux de sortie vers un fichier�;
- java.io.FilterOutputStream - classe de base pour tous les d�corateurs permettant de filtrer le contenu du flux d�entr�e�:
- java.io.BufferedOutputStream - d�core un flux de sortie en lui associant un tampon m�moire,
- java.io.DataOutputStream - d�core un flux de sortie de mani�re � pouvoir y �crire des types Java primitifs,
- java.io.PrintStream - d�core un flux de sortie de mani�re � pouvoir utiliser des m�thodes de formatage de chaines de caract�res�;
- java.io.ObjectOutputStream - d�core un autre flux de sortie pour permettre de s�rialiser un objet�;
- java.io.java.io.PipedOutputStream - permet de connecter un flux d�entr�e PipedInputStream sur un flux de sortie.
Dans l'API Java classique, les objets Reader (liseuse) et Writer (machine � �crire, producteur de texte) permettent de manipuler plus ais�ment des flux contenant des caract�res (character stream), par exemple�: des fichiers texte ou l�entr�e et la sortie de la console, chaine de caract�res en m�moire. Ces classes offrent une abstraction permettant de s'affranchir du flux d'octets sur lequel repose le flux de caract�res. Ces classes sont les bases de tout un ensemble de sous-classes sp�cialis�es (ex.�: liseuse de fichiers, liseuse de flux, liseuse de lignes, liseuse avec tampon, etc.) qu'il est possible de composer entre elles pour manipuler la source ou la destination sous-jacente de mani�re efficace. La plupart des op�rations de lecture ou d��criture sur les liseuses et les producteurs sont susceptibles de g�n�rer des exceptions de type IOException en cas d'erreur.
De par leur nature, les readers et les writers sont attach�s � des flux de caract�res qui empaquettent eux-m�mes des flux d'octets qui sont donc li�s � des ressources natives (fichiers, sockets, etc.) qui doivent �tre lib�r�es lorsque vous avez fini d'utiliser le flux. Vous devez donc invoquer leur m�thode close() lorsque vous avez fini de les manipuler. Les readers et writers impl�mentent l'interface AutoClosable, il est ainsi possible de les utiliser dans une construction try-with-resources qui fermera automatiquement la liseuse ou le producteur en fin de bloc.
Reader
La classe java.io.Reader ainsi que ses classes d�riv�es sp�cialis�es permettent de lire le contenu d'un flux s�quentiel de caract�res. Quand vous lisez le contenu d'un reader, ce dernier va, en fonction de l'encodage choisi, interpr�ter les octets contenus dans le flux d�entr�e sous-jacent pour les convertir en caract�res.
Par exemple, pour lire le contenu d'un fichier texte avec l'API Java classique, on fera�:
Code Java : | S�lectionner tout |
1 2 3 4 | try (LineNumberReader reader = new LineNumberReader(new FileReader("fichier.txt"))) { // Lecture du fichier texte. [...] } |
Et avec NIO2, on fera�:
Code Java : | S�lectionner tout |
1 2 3 4 | try (LineNumberReader reader = new LineNumberReader(Files.newBufferedReader(Paths.get("fichier.txt")))) { // Lecture du fichier texte. [...] } |
Writer
La classe java.io.Writer ainsi que ses classes d�riv�es sp�cialis�es permettent d��crire dans un flux s�quentiel de caract�res. Quand vous �crivez du contenu sur un writer, ce dernier va, en fonction de l'encodage choisi, convertir les caract�res �crits en octets qui seront transmis au flux de sortie sous-jacent.
Par exemple, pour �crire le contenu d'un fichier texte avec l'API Java classique, on fera�:
Code Java : | S�lectionner tout |
1 2 3 4 | try (PrintWriter writer = new PrintWriter(new FileWriter("fichier.txt"))) { // �criture du fichier texte. [...] } |
Et avec NIO2, on fera�:
Code Java : | S�lectionner tout |
1 2 3 4 | try (PrintWriter writer = new PrintWriter(Files.newBufferedWriter(Paths.get("fichier.txt")))) { // �criture du fichier texte. [...] } |
Le patron de conception
d�corateur est largement utilis� par les liseuses�; certaines classes sont donc destin�es � ajouter des nouveaux comportements et de nouvelles fonctionnalit�s aux readers de base. Voici quelques-unes des classes de liseuses que vous serez amen�s � manipuler le plus souvent�:
- java.io.BufferedReader - classe de base pour tous les d�corateurs permettant d'associer un tampon m�moire au contenu de la liseuse�:
- java.io.LineNumberReader - d�corateur qui garde trace du nombre de lignes de texte lues�;
- java.io.LineNumberReader - d�corateur qui garde trace du nombre de lignes de texte lues�;
- java.io.CharArrayReader - permet de manipuler un tableau de caract�res (char[]) comme une liseuse�;
- java.io.InputStreamReader - empaqu�te un flux d�entr�e (InputStream) dans une liseuse�:
- java.io.FileReader - empaqu�te un flux d�entr�e sur un fichier (FileInputStream) dans une liseuse�;
- java.io.FileReader - empaqu�te un flux d�entr�e sur un fichier (FileInputStream) dans une liseuse�;
- java.io.PipedReader - permet de connecter un producteur PipedWriter sur une liseuse�;
- java.io.StringReader - permet de manipuler une chaine de caract�res (String) comme une liseuse.
Le patron de conception
d�corateur est largement utilis� par les producteurs�; certaines classes sont donc destin�es � ajouter des nouveaux comportements et de nouvelles fonctionnalit�s aux writers de base. Voici quelques-unes des classes de producteurs que vous serez amen�s � manipuler le plus souvent�:
- java.io.BufferedWriter - d�core un producteur en lui s�associant un tampon m�moire �;
- java.io.CharArrayWriter - permet de manipuler un tableau de caract�res (char[]) dans un producteur�;
- java.io.OutputStreamWriter - empaqu�te un flux de sortie (OutputStream) dans un producteur�;
- java.io.FileReader - empaqu�te un flux de sortie vers un fichier (FileOutputStream) dans un producteur�:
- java.io.PipedWriter - permet de connecter une liseuse PipedReader sur un producteur�;
- java.io.PrintWriter - d�core un producteur de mani�re � pouvoir utiliser des m�thodes de formatage de chaines de caract�res�;
- java.io.StringWriter - permet de manipuler un constructeur de chaines de caract�res (StringBuffer) comme un producteur de mani�re � produire des chaines de caract�res (String).
Il arrive que l�acc�s de mani�re s�quentielle aux octets d'un fichier via les flux ne soit pas suffisant pour des op�rations de lecture/�criture. Ceci est souvent le cas lorsqu'on g�re des fichiers binaires dans lesquels un acc�s direct (ou acc�s al�atoire, random access) est souvent requis�: il faut sauter � un d�calage sp�cifique dans le fichier ou revenir en arri�re plus tard, remplacer le contenu d'un groupe sp�cifique d'octets, etc. M�me si certains types de flux peuvent supporter la notion de marque et de restauration de contexte, ce n'est pas toujours le cas et ils se r�v�lent en g�n�ral peu adapt�s � cet usage.
Dans l'API Java classique, la classe java.io.RandomAccessFile permet de b�n�ficier d'un acc�s direct tant en lecture qu'en �criture sur un fichier. Cette classe permet de d�placer un curseur � un d�calage sp�cifique dans le fichier en invoquant la m�thode seek(), ce qui permet d'effectuer l�op�ration de lecture ou d��criture � cet emplacement pr�cis. La plupart des op�rations sur cette classe sont susceptibles de g�n�rer des exceptions de type IOException en cas d'erreur.
De par sa nature, cette classe est attach�e � une ressource native (fichier) qui doit �tre lib�r�e lorsque vous avez fini d'utiliser l'instance. Vous devez donc invoquer sa m�thode close() lorsque vous avez fini de la manipuler. Cette classe impl�mente l'interface AutoClosable, il est ainsi possible de l'utiliser dans une construction try-with-resources qui fermera automatiquement l'instance en fin de bloc.
Avertissent�: vous devez garder � l'esprit que Java est Big-Endian. Lorsque vous lisez ou �crivez une structure d'octets complexe (short, int, long, etc.) dans un tel fichier, cette derni�re sera lue ou �crite au format Big-Endian�!
De plus, vous devez �galement vous rappeler que les caract�res en Java (char) sont cod�s sur 16�bits (2 octets) et non pas sur 8�bits (1 octet) comme dans d'autres langages.
Pour ouvrir un fichier en acc�s direct en lecture�:
Code Java : | S�lectionner tout |
1 2 3 4 | try (RandomAccessFile file = new RandomAccessFile("fichier.bin", "r")) { // Lecture du fichier. [...] } |
Et pour un acc�s direct en �criture�:
Code Java : | S�lectionner tout |
1 2 3 4 | try (RandomAccessFile file = new RandomAccessFile("fichier.bin", "rw")) { // �criture du fichier. [...] } |
Dans l'API NIO, un canal ou channel est un concept introduit dans le JDK�1.4 et mis en �uvre via l'interface java.nio.channels.Channel ainsi que ses interfaces filles et ses nombreuses impl�mentations. Un canal repr�sente une connexion vers une entit� telle qu'un fichier, un p�riph�rique, une socket r�seau ou encore une partie d'un logiciel, etc. capable d'effectuer des op�rations I/O telles que la lecture et l��criture. Un canal a deux �tats�: ouvert ou ferm�; il est ouvert lors de sa cr�ation et peut �tre alors ferm�. Une fois qu'il est ferm�, le canal le reste.
Les canaux sont destin�s � permettre d'effectuer des op�rations en acc�s direct (ou acc�s al�atoire ou random access) de mani�re non bloquante (asynchrone). Ils permettent, entre autres de manipuler des fichiers de tr�s grande taille. Par exemple, la classe java.nio.channels.FileChannel permet d'obtenir un canal permettant de manipuler un fichier. Cette classe h�rite de plusieurs types de canaux qui lui permettent de lire et d��crire des octets, mais aussi de d�placer son curseur de lecture/�criture dans le fichier et de mapper un tampon m�moire contenant une partie du fichier, ce que ne permet pas de faire ais�ment un flux classique.
De par sa nature, cette classe est attach�e � une ressource native (fichier) qui doit �tre lib�r�e lorsque vous avez fini d'utiliser l'instance. Vous devez donc invoquer sa m�thode close() lorsque vous avez fini de la manipuler. Cette classe impl�mente l'interface AutoClosable, il est ainsi possible de l'utiliser dans une construction try-with-resources qui fermera automatiquement l'instance en fin de bloc.
Voici quelques-unes des classes de canaux que vous serez amen�s � manipuler le plus souvent�:
- java.nio.channels.AsynchronousFileChannel - un canal associ� � un fichier supportant les op�rations asynchrones�;
- java.nio.channels.AsynchronousServerSocketChannel - un canal associ� � une socket serveur supportant les op�rations asynchrones�;
- java.nio.channels.AsynchronousSocketChannel- un canal associ� � une socket supportant les op�rations asynchrones�;
- java.nio.channels.DatagramChannel - un canal associ� � une socket supportant les
datagrammes�;
- java.nio.channels.FileChannel - un canal associ� � un fichier�;
- java.nio.channels.ServerSocketChannel - un canal associ� � une socket serveur�;
- java.nio.channels.SocketChannel - un canal associ� � une socket.
Dans l'API NIO, un tampon ou buffer est un concept introduit dans le JDK�1.4 et mis en �uvre via la classe java.nio.Buffer ainsi que ses classes filles. Ces objets sont utilis�s pour lire et �crire des donn�es sur les canaux. Un tampon repr�sente un espace lin�aire et fini (d'une capacit� limit�e) d'un certain type de donn�es (byte, char, short, etc.).
Un tampon contient �galement un curseur qui est la position � laquelle peut s'effectuer l�op�ration de lecture/�criture�; cette position ne peut pas �tre n�gative ou �tre positionn�e au-del� de la limite du tampon. La limite est la position maximale des donn�es au-del� de laquelle on ne peut plus lire ni �crire. Il est de plus possible de poser une marque qui permet un retour rapide du curseur � cette position. De mani�re g�n�rale on a�: 0 ≤ marque ≤ position ≤ limite ≤ capacit�.
Les tampons disposent de plusieurs m�thodes dont il faut bien comprendre l'usage�:
- clear() - cette op�ration r�initialise compl�tement le tampon, sa position et sa capacit�. Elle doit �tre invoqu�e avant de lire le contenu d'un canal�;
- flip() - cette op�ration modifie la limite � la positon actuelle avant de r�initialiser la position. Elle doit �tre invoqu�e avant de pouvoir �crire un tampon dans un canal�;
- rewind() - cette op�ration r�initialise la position et permet d�acc�der � nouveau aux donn�es contenues. Elle peut �tre utilis�e pour, par exemple, copier le contenu d'un tampon dans un tableau apr�s que le tampon a �t� �crit dans un canal.
Voici quelques-unes des classes de tampons que vous serez amen�s � manipuler le plus souvent�:
- java.nio.ByteBuffer - un tampon de bytes (octets)�:
- java.nio.MappedByteBuffer - un tampon d'octets dans une r�gion de la m�moire en acc�s direct cr�� � partir d'un canal vers un fichier (FileChannel)�;
- java.nio.MappedByteBuffer - un tampon d'octets dans une r�gion de la m�moire en acc�s direct cr�� � partir d'un canal vers un fichier (FileChannel)�;
- java.nio.CharBuffer - un tampon sp�cialis� dans la manipulation de char obtenu � partir d'un ByteBuffer�;
- java.nio.DoubleBuffer - un tampon sp�cialis� dans la manipulation de double obtenu � partir d'un ByteBuffer�;
- java.nio.FloatBuffer - un tampon sp�cialis� dans la manipulation de float obtenu � partir d'un ByteBuffer�;
- java.nio.IntBuffer - un tampon sp�cialis� dans la manipulation d'int obtenu � partir d'un ByteBuffer�;
- java.nio.LongBuffer - un tampon sp�cialis� dans la manipulation de long obtenu � partir d'un ByteBuffer�;
- java.nio.ShortBuffer - un tampon sp�cialis� dans la manipulation de short obtenu � partir d'un ByteBuffer.
La machine virtuelle Java (et plus pr�cis�ment le Garbage Collector ou ramasse-miettes) s'occupe de lib�rer proprement la m�moire lorsque les objets ne sont plus utilis�s. Toutefois, il existe un certain nombre de ressources qui doivent �tre lib�r�es explicitement, par exemple les fichiers, les sockets ou les connexions JDBC, car elles utilisent des ressources syst�me qui ne peuvent pas �tre g�r�es par le Garbage Collector. Ces ressources doivent �tre ��lib�r�es�� explicitement gr�ce � une m�thode sp�cifique (g�n�ralement nomm�e close()).
Or, on ne peut pas se contenter d'appeler cette m�thode � la fin du traitement, car il y a un certain nombre de cas o� cette m�thode ne serait pas appel�e�; par exemple en cas d'exception ou de retour de la m�thode. Il est �galement fortement d�conseill� d'appeler cette m�thode aux divers points de sortie du code (fin du traitement, dans les catch, avant les return, etc.), car cela complexifie le code et son traitement, et augmente ainsi les chances de se tromper (en oubliant un cas particulier par exemple).
JDK ant�rieurs au JDK�7
La solution la plus propre � mettre en �uvre est d'utiliser un bloc try/finally qui respecte la structure suivante�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 | // 1 - Cr�ation de la ressource. try { // 2 - Utilisation de la ressource. } finally { // 3 - Lib�ration de la ressource. } |
Ainsi, lorsque la ressource est correctement cr��e, on l'utilise exclusivement � l'int�rieur du try, et on la lib�re dans le bloc finally quoi qu'il arrive. En effet, si on rentre dans le bloc try, le code du bloc finally sera ex�cut� dans tous les cas lorsqu'on sort de celui-ci, m�me si une exception est g�n�r�e ou que l'on quitte la m�thode avec return... Cette organisation en trois �tapes permet donc de garantir la lib�ration propre des ressources dans tous les cas.
Par exemple le code permettant de lire un fichier texte pourrait ressembler � ceci�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | public static String readFile(File file) throws IOException, FileNotFoundException { // 1 - Cr�ation de la ressource. FileReader reader = new FileReader(file); try { // 2 - Utilisation de la ressource. StringBuffer buffer = new StringBuffer(); char[] cbuf = new char[2048]; int len; while ((len = reader.read(cbuf)) > 0) { buffer.append(cbuf, 0, len); } return buffer.toString(); } finally { // 3 - Lib�ration de la ressource. reader.close(); } } |
Cela permet de faire remonter simplement les exceptions � la m�thode appelante tout en fermant correctement la ressource (ici, une instance de FileReader).
De la m�me mani�re, si l'on souhaite g�rer les exceptions dans la m�thode, il est pr�f�rable d'utiliser un bloc try/catch en plus du bloc try/finally et non pas un bloc try/catch/finally qui n�cessiterait un nouveau try/catch dans le bloc finally (et donc un double traitement des exceptions).
Par exemple�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | public static String readFile(File file) { try { // 1 - Cr�ation de la ressource. FileReader reader = new FileReader(file); try { // 2 - Utilisation de la ressource. StringBuffer buffer = new StringBuffer(); char[] cbuf = new char[2048]; int len; while ( (len = reader.read(cbuf)) > 0 ) { buffer.append(cbuf, 0, len); } return buffer.toString(); } finally { // 3 - Lib�ration de la ressource. reader.close(); } } catch (IOException e) { e.printStackTrace(); return null; } } |
Enfin, si l'on utilise plusieurs ressources � la fois, il ne faut pas h�siter � encapsuler plusieurs try/finally (un par ressource). Par exemple dans ce code qui permet de sauvegarder une URL dans un fichier�:
Code java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | public static void writeToFile(URL url, File file) throws IOException, FileNotFoundException { // 1 - Cr�ation de la ressource (Fichier). FileOutputStream fos = new FileOutputStream(file); try { // 2 - Utilisation de la ressource (Fichier). // 1 - Cr�ation de la ressource (URL). InputStream is = url.openStream(); try { // 2 - Utilisation de la ressource (URL). byte[] buf = new byte[2048]; int len; while ( (len = is.read(buf)) > 0) { fos.write(buf, 0 , len); } } finally { // 3 - Lib�ration de la ressource (URL). is.close(); } } finally { // 3 - Lib�ration de la ressource (Fichier). fos.close(); } } |
Si cela peut avoir peu d'importance dans une application de bureau, c'est nettement plus critique dans une application serveur, car on peut vite atteindre les limites autoris�es par le syst�me, et se retrouver avec une application compl�tement bloqu�e�!
� noter enfin que le Garbage Collector ��limite�� quand m�me ce ph�nom�ne, car la m�thode close() est g�n�ralement appel�e implicitement lors de la destruction de l'objet (plus pr�cis�ment via la m�thode finalize()) si la ressource n'a pas �t� ferm�e explicitement. Toutefois, �tant donn� que l'on ne peut pas ma�triser le passage du Garbage Collector avec exactitude, il est pr�f�rable de fermer les ressources explicitement avec un bloc try/finally.
JDK7
� partir du JDK7, il est possible de largement simplifier ces bouts de code en utilisant une construction de type try-with-resource qui se chargera d'invoquer les m�thodes close() de toutes les ressources de type AutoClosable qui y ont �t� d�clar�es.
Pour la lecture de fichier simple�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | public static String readFile(File file) throws IOException, FileNotFoundException { // 1 - Cr�ation de la ressource try (FileReader reader = new FileReader(file)) { // 2 - Utilisation de la ressource StringBuffer buffer = new StringBuffer(); char[] cbuf = new char[2048]; int len; while ((len = reader.read(cbuf)) > 0) { buffer.append(cbuf, 0, len); } return buffer.toString(); // 3 - Lib�ration implicite de la ressource. } } |
Pour la lecture de fichier avec interception d'exception�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | public static String readFile(File file) { // 1 - Cr�ation de la ressource try (FileReader reader = new FileReader(file)) { // 2 - Utilisation de la ressource StringBuffer buffer = new StringBuffer(); char[] cbuf = new char[2048]; int len; while ((len = reader.read(cbuf)) > 0) { buffer.append(cbuf, 0, len); } return buffer.toString(); // 3 - Lib�ration implicite de la ressource. } catch (IOException e) { e.printStackTrace(); return null; } } |
Pour la gestion de plusieurs ressources�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 | public static void writeToFile(URL url, File file) throws IOException, FileNotFoundException { // 1 - Cr�ation des ressources (Fichier et URL). try (FileOutputStream fos = new FileOutputStream(file); InputStream is = url.openStream()) { // 2 - Utilisation des ressources (Fichier et URL) byte[] buf = new byte[2048]; int len; while ((len = is.read(buf)) > 0) { fos.write(buf, 0, len); } // 3 - Lib�ration implicite des ressources (Fichier et URL). } } |
Ici, lors de la sortie du bloc try, les m�thodes des deux flux sont implicitement invoqu�es dans l'ordre inverse de la d�claration des flux (la m�thode close() de is sera invoqu�e avant la m�thode close() de fos).
Les sorties standards sont accessibles au programmeur gr�ce aux flux statiques out et err de la classe java.lang.System. Le flux in permet d�acc�der � la sortie standard tandis que le flux err permet d�acc�der �
l'erreur standard.
Ces deux flux sont des instances de la classe java.io.PrintStream�; cette classe permet d'utiliser les variantes des m�thodes print() et println() pour effectuer des sorties format�es. Depuis le JDK�5, il est �galement possible d'utiliser les variantes des m�thodes printf() et format().
Code Java : | S�lectionner tout |
1 2 3 4 | // Imprime sur la sortie standard. System.out.println("Salut le monde�!"); // Imprime sur l'erreur standard. System.err.println("Erreur"); |
Avertissement�: si vous invoquez la m�thode close() sur ces flux, vous ne pourrez plus les ouvrir apr�s cet appel et tout ce que vous imprimerez sur les sorties sera alors perdu.
L'entr�e standard est accessible au programmeur gr�ce au flux statique in de la classe java.lang.System. Si vous ex�cutez votre application dans une console, elle contiendra tous les caract�res entr�s au clavier.
JDK ant�rieur au JDK 5
La manipulation directe du flux n'�tant pas tr�s ais�e, une petite conversion en java.io.BufferedReader s'impose.
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 | BufferedReader entree = new BufferedReader(new InputStreamReader(System.in)); try { // Lecture d'une ligne�: String ligne = entree.readLine(); } catch( IOException e ) { e.printStackTrace(); } |
La lecture d'une ligne est une m�thode dite ��bloquante���: c'est-�-dire que le processus appelant est en pause tant que l'utilisateur n'a pas appuy� sur la touche Entr�e du clavier.
Note�: Ici, on n'invoque pas la m�thode close() des liseuses pour ne pas fermer le flux d�entr�e de la console.
JDK 5
� partir du JDK 5, vous pouvez aussi utiliser un java.util.Scanner pour parser la sortie standard.
Par exemple�:
Code Java : | S�lectionner tout |
1 2 3 4 | Scanner scanner = new Scanner(System.in); // Traitement. [...] scanner.close(); |
Le Scanner a l'avantage de poss�der un ensemble de m�thodes permettant de lire directement les types primitifs. Vous pouvez aussi l'utiliser pour faire des recherches dans les flux scann�s avec des expressions r�guli�res.
JDK 6
� partir du JDK 6, il est possible de lire sur l'entr�e standard via la classe java.io.Console.
Par exemple�:
Code Java : | S�lectionner tout |
1 2 | Console console = System.console(); String ligne = console.readLine(); |
La classe Console propose �galement la m�thode readPassword() qui n'affiche pas les caract�res sur la console.
Si pour une raison quelconque, vous avez besoin de r�cup�rer dans des fichiers tout ce qui arrive sur la sortie standard, il suffit d'employer les m�thodes setOut() et setErr() de la classe System :
Code Java : | S�lectionner tout |
1 2 | System.setOut(new PrintStream(new FileOutputStream("out.log"))); System.setErr(new PrintStream(new FileOutputStream("err.log"))); |
Oui, cela est possible. Ceci peut �tre utile par exemple pour afficher correctement les caract�res accentu�s.
Voici un exemple permettant d'�crire correctement les caract�res accentu�s sur la console Windows (DOS, CMD) :
Code Java : | S�lectionner tout |
1 2 3 4 5 | PrintStream ps = new PrintStream(System.out, true, "IBM850"); // On commence par changer l'encodage en IBM850 (connu aussi sous l'alias Cp850). System.setOut(ps); // Ensuite, l'utilisation de la sortie standard reste la m�me System.out.println("��������������������������"); |
Pour charger une ressource pr�sente sur le CLASSPATH (depuis un r�pertoire ou une archive JAR), il faut utiliser les m�thodes getResource() et getResourceAsStream() de la classe Class. Le chemin � passer en argument est celui commen�ant dans le r�pertoire du CLASSPATH ou � la racine d'un fichier JAR.
Attention : si le chemin ne commence pas par / alors le package courant est ajout� au d�but du chemin.
Par exemple�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 | package com.developpez; public class Test { public Test() { try (InputStream is1 = getClass().getResourceAsStream("fichier.txt") ; InputStream is2 = getClass().getResourceAsStream("/fichier.txt")) { [...] } } } |
Dans le code de l'exemple, is1 sera un flux ouvert sur un fichier com/developpez/fichier.txt pr�sent dans un des r�pertoires du CLASSPATH ou dans la m�me arborescence � partir de la racine d'un fichier JAR du CLASSPATH. is2 sera, quant � lui, un flux ouvert sur un fichier fichier.txt pr�sent directement dans un r�pertoire du CLASSPATH ou � la racine d'un fichier JAR.
On peut sp�cifier l'encodage utilis� pour lire un flux. Voici un exemple qui lit un fichier en UTF-8 et �crit celui-ci en ISO-8859-1 :
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 | public static void toISO(String source, String destination){ try (BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(source),"UTF-8")) ; // Flux de lecture en UTF-8. PrintWriter pw = new PrintWriter(new FileOutputStream(destination))) { // Flux d'�criture en ISO (valeur par d�faut). String ligne; while ((ligne = br.readLine()) != null) { pw.println(ligne); } } catch (Exception e) { e.printStackTrace(); } } |
La classe java.nio.Charset nous permet de facilement acc�der � ces informations.
Voici un exemple listant l'ensemble des charsets disponibles :
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 | SortedMap<String,Charset> charsets = Charset.availableCharsets(); for (String nom : charsets.keySet()) { System.out.println("Charset "+nom); Charset charset = charsets.get(nom); for (String alias : charset.aliases()) { System.out.print(" "+alias+","); } System.out.println(); } |
JDK ant�rieurs au JDK�7
Il est possible d'obtenir une instance de FileChannel en invoquant la m�thode getChannel() des classes de l'API Java classique�: java.io.FileInputStream, java.io.FileOutputStream et java.io.RandomAccessFile.
Code Java : | S�lectionner tout |
1 2 3 4 5 6 | try (FileChannel channel = new RandomAccessFile("fichier.bin", "r").getChannel()) { // Faire quelque chose sur le fichier. [...] } catch (IOException ex) { System.out.println("Erreur --" + ex.toString()); } |
Le canal ainsi obtenu est un singleton et toute modification effectu�e sur le canal (�criture, d�placement de curseur, etc.) s'appliquera �galement sur le flux ou le fichier parent et inversement.
JDK�7
� partir du JDK�7, il est possible d'invoquer la m�thode statique open() de la classe java.nio.channels.FileChannel pour obtenir un tel canal�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 | try (FileChannel channel = FileChannel.open(Paths.get("fichier.bin"), StandardOpenOption.READ)) { // Faire quelque chose sur le fichier. [...] } catch (IOException ex) { System.out.println("Erreur --" + ex.toString()); } |
Il est �galement possible d'invoquer la m�thode statique newByteChannel() de la classe utilitaire java.nio.file.Files�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 | try (SeekableByteChannel channel = Files.newByteChannel(Paths.get("fichier.bin"), StandardOpenOption.READ)) { // Faire quelque chose sur le fichier. [...] } catch (IOException ex) { System.out.println("Erreur --" + ex.toString()); } |
Vous pouvez utiliser une ou plusieurs des valeurs d�finies dans l'enum java.nio.file.StandardOpenOption pour modifier le mode d'ouverture de votre canal�:
- StandardOpenOption.APPEND - l��criture se fait en fin de fichier�;
- StandardOpenOption.CREATE - si le fichier n'existe pas, le cr�er�; ne rien faire si le fichier existe�;
- StandardOpenOption.CREATE_NEW - si le fichier n'existe pas, le cr�er�; g�n�rer une exception si le fichier existe�;
- StandardOpenOption.DELETE_ON_CLOSE - tente de supprimer le fichier � la fermeture du canal�; sinon tenter de le supprimer lorsque la JVM se termine (sans erreur)�;
- StandardOpenOption.DSYNC - force l��criture imm�diate de toutes modifications du fichier de mani�re synchrone�;
- StandardOpenOption.READ - ouverture en lecture�;
- StandardOpenOption.SPARSE - tente de cr�er
un fichier compact si le syst�me de fichier supporte cette option�;
- StandardOpenOption.SYNC - force l��criture imm�diate de toutes modifications du fichier ou de ses m�tadonn�es de mani�re synchrone�;
- StandardOpenOption.TRUNCATE_EXISTING - tronque tout fichier existant en mettant sa taille � z�ro�;
- StandardOpenOption.WRITE - ouverture en �criture.
Note�: si vous obtenez votre canal � partir des classes de l'API Java classique, le canal obtenu h�ritera ses capacit�s de celles de son parent�:
- FileInputStream - le canal peut �tre utilis� uniquement en lecture�: �quivalent de StandardOpenOption.READ�;
- FileOutputStream - le canal peut �tre utilis� uniquement en �criture. Si le param�tre append vaut�:
- true�: �quivalent de StandardOpenOption.CREATE + StandardOpenOption.APPEND + StandardOpenOption.WRITE,
- false�: �quivalent de StandardOpenOption.CREATE + StandardOpenOption.TRUNCATE_EXISTING + StandardOpenOption.WRITE�;
- RandomAccessfile - le mode du canal d�pend du mode d'ouverture du fichier�:
- "r"�: �quivalent de StandardOpenOption.READ,
- "rw"�: �quivalent de StandardOpenOption.CREATE + StandardOpenOption.WRITE + StandardOpenOption.READ.
Il est possible de cr�er un tampon en m�moire en invoquant la m�thode map() de la classe java.nio.channels.FileChannel.
Par exemple pour un petit fichier, nous pouvons faire�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 | try (FileChannel channel = FileChannel.open(Paths.get("fichier.bin"), StandardOpenOption.READ)) { MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size()); [...] } catch (IOException ex) { System.out.println("Erreur --" + ex.toString()); } |
Ici, nous avons mapp� le contenu du fichier en m�moire dans son int�gralit�.
Pour des fichiers de plus grande taille, il faudra s�attacher travailler sur le fichier ��par morceau�� et � d�placer le tampon comme si on d�pla�ait une vue ou une fen�tre sur le contenu du fichier.
Java est Big-Endian et ses flux ainsi que la classe RandomAccessFile lisent les donn�es en Big-Endian �galement. Ceci peut poser probl�me si vous cherchez � lire ou � �crire des fichiers dont le format est originaire du monde du PC (par exemple des anciens formats binaires pour Microsoft Office). En effet�:
- Big-Endian - les octets de poids fort sont � gauche�: architecture IBM, CRAY, Sun, etc.�;
- Little-Endian - les octets de poids faible sont � gauche�: architecture Intel.
Prenons par exemple le nombre entier (32bit) 3�:
Code Console : | S�lectionner tout |
1 2 | 3 sur une machine gros-boutiste ↔ 00000000 00000000 00000000 00000011 ↔ 50331648 sur une machine petit-boutiste. 3 sur une machine petit-boutiste ↔ 00000011 00000000 00000000 00000000 ↔ 50331648 sur une machine gros-boutiste. |
API Java classique
Il n'existe pas de m�thode standardis�e dans l'API classique pour lire et �crire des donn�es binaires au format Little-Endian. En l'absence de m�thode standard, vous allez devoir vous cr�er des routines qui vous permettent d'inverser les octets lors de la lecture ou de l��criture de structures d'octets complexes (short, int, long, etc.). Par exemple, la m�thode suivante inverse les octets d'un int (entier 32bit)�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 | public static int invertIntBytes(int value) { int a = (value >> 24) & 0xFF; int b = (value >> 16) & 0xFF; int c = (value >> 8) & 0xFF; int d = value & 0xFF; int result = (d << 24) | (c << 16) | (b << 8) | a; return result; } |
Vous devrez ensuite invoquer cette m�thode au moment appropri� lors de la lecture ou de l��criture de votre fichier.
Pour la lecture�:
Code Java : | S�lectionner tout |
1 2 3 4 5 | try (DataInputStream input = new DataInputStream(new FileInputStream("fichier.bin"))) { int value = invertIntBytes(input.readInt()); // Pour lire 3, il faudra lire 00000011 00000000 00000000 00000000. } catch (IOException ex) { System.out.println("Erreur --" + ex.toString()); } |
Pour l��criture�:
Code Java : | S�lectionner tout |
1 2 3 4 5 | try (DataOutputStream output = new DataOutputStream(new FileOutputStream("fichier.bin"))) { output.writeInt(invertIntBytes(3)); // Le contenu g�n�r� sera 00000011 00000000 00000000 00000000. } catch (IOException ex) { System.out.println("Erreur --" + ex.toString()); } |
NIO
Vous pouvez invoquer la m�thode order() d'un ByteBuffer en lui passant en param�tre une instance de la classe java.nio.ByteOrder. Actuellement, cette classe d�finit deux valeurs�:
- ByteOrder.BIG_ENDIAN - les octets de poids fort sont � gauche�: architecture IBM, CRAY, Sun, etc. Il s'agit de la valeur par d�faut puisque Java est Big-Endian�;
- ByteOrder.LITTLE_ENDIAN - les octets de poids faible sont � gauche�: architecture Intel.
Pour la lecture�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 | try (FileChannel channel = FileChannel.open(Paths.get("fichier.bin"), StandardOpenOption.READ)) { MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size()); buffer.order(ByteOrder.LITTLE_ENDIAN); final int value = buffer.getInt(); // Pour lire 3, il faudra lire 00000011 00000000 00000000 00000000. System.out.println(value); } catch (IOException ex) { System.out.println("Erreur --" + ex.toString()); } |
Pour l��criture�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 | try (FileChannel channel = FileChannel.open(Paths.get("fichier.bin"), StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.WRITE)) { ByteBuffer buffer = ByteBuffer.allocate(4); buffer.order(ByteOrder.LITTLE_ENDIAN); buffer.putInt(3); // Le contenu g�n�r� sera 00000011 00000000 00000000 00000000. buffer.flip(); channel.write(buffer); } catch (IOException ex) { System.out.println("Erreur --" + ex.toString()); } |
Invoquer la m�thode order() (sans param�tre) retourne la configuration du tampon.
Le traitement d'un fichier ligne par ligne est assez simple, mais il faut quand m�me conna�tre les diff�rentes mani�res de s'y prendre�:
API Java classique
BufferedReader
Nous allons utiliser un simple BufferedReader pour lire le fichier et ensuite utiliser la m�thode readLine() pour lire une ligne de notre fichier. Voil� donc ce que pourrait donner notre code�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 | try (BufferedReader buff = new BufferedReader(new FileReader("fichier.txt"))) { String line; // Lecture du fichier ligne par ligne. // Cette boucle se termine quand la m�thode retourne la valeur null. while ((line = buff.readLine())�!= null) { System.out.println(line); // Faites ici votre traitement. [...] } } catch (IOException ioe) { System.out.println("Erreur --" + ioe.toString()); } |
LineNumberReader
La classe LineNumberReader permet �galement de conna�tre les num�ros des lignes lues dans le fichier.
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | try (LineNumberReader buff = new LineNumberReader(new FileReader("fichier.txt"))) { String line; // Lecture du fichier ligne par ligne. // Cette boucle se termine quand la m�thode retourne la valeur null. try { while ((line = buff.readLine())�!= null) { System.out.println(line); // Faites ici votre traitement. [...] } } catch (IOException ioe) { System.out.println("Erreur ligne #" + buff.getLineNumber()); throw ioe; } } catch (IOException ioe) { System.out.println("Erreur --" + ioe.toString()); } |
Scanner
� partir du JDK�5, on peut �galement utiliser la classe java.util.Scanner pour lire un fichier ligne par ligne�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 | try (Scanner scanner = new Scanner(new File("fichier.txt"))) { // On boucle sur chaque champ d�tect�. while (scanner.hasNextLine()) { String line = scanner.nextLine(); System.out.println(line); // Faites ici votre traitement. [...] } } catch (FileNotFoundException ex) { System.out.println("Erreur --" + ex.toString()); } |
NIO2
JDK�7
� partir du JDK�7, il est possible d'invoquer la m�thode statique readAllLines() de la classe utilitaire java.nio.file.Files pour lire toutes les lignes d'un fichier texte�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 | try { List<String> lines = Files.readAllLines(Paths.get("fichier.txt")); for (String line�: lines) { System.out.println(line); // Faites ici votre traitement. [...] } } catch (IOException ex) { System.out.println("Erreur --" + ex.toString()); } |
Cette m�thode est bloquante tant que le contenu du fichier n'a pas �t� int�gralement charg� en m�moire.
JDK�8
� partir du JDK�8, il est possible d'utiliser les flux de donn�es (data stream ou stream) en invoquant la m�thode statique lines() de la classe utilitaire java.nio.file.Files pour lire toutes les lignes d'un fichier texte�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 | try (Stream<String> lines = Files.lines(Paths.get("fichier.txt"))) { lines.forEach(line -> { System.out.println(line); // Faites ici votre traitement. [...] }); } catch (IOException ex) { System.out.println("Erreur --" + ex.toString()); } |
Le flux retourn� par l'invocation de cette m�thode est peupl� de mani�re lazy (paresseuse), c'est-�-dire que le fichier n'est pas int�gralement lu � l'avance et les lignes de texte sont charg�es en m�moire au au fur et � mesure de l�acc�s au contenu du flux.
� partir du JDK�5, pour lire les �l�ments d'un fichier en utilisant un d�limiteur, il suffit d'avoir recours � la classe java.util.Scanner.
Par exemple pour lire un fichier dont les champs sont s�par�s par des tabulations, on pourra �crire�:
Code Java : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 | try (Reader reader = new FileReader("fichier.txt")) { Scanner scanner = new Scanner(reader); // L'expression r�guli�re qui d�limite les champs. scanner.useDelimiter(Pattern.compile("[\t\n]")); // On boucle sur chaque champ d�tect�. int champ; while (scanner.hasNext()) { // Si le champ n'est pas un entier, une exception de type InputMismatchException sera g�n�r�e. champ = scanner.nextInt(); // Utilisation du champ... [...] } } |
API Java classique
FileOutputStream
Pour �crire � la fin d'un fichier binaire, il faut utiliser la classe java.io.FileOutputStream�; cette classe poss�de des constructeurs acceptant parmi leurs arguments un bool�en nomm� append. Si cet argument est positionn� � la valeur true, les donn�es �crites dans ce fichier seront mises � la fin de celui-ci�:
Code Java : | S�lectionner tout |
1 2 3 4 | String texte = "texte � ins�rer � la fin du fichier"; try (FileOutputStream output = new FileOutputStream("fichier.bin", true)) { output.write(texte.getBytes("utf-8")); } |
Writer
Pour �crire � la fin d'un fichier texte, il faut utiliser la classe java.io.FileWriter�; cette classe poss�de des constructeurs acceptant parmi leurs arguments un bool�en nomm� append. Si cet argument est positionn� � la valeur true, les donn�es �crites dans ce fichier seront mises � la fin de celui-ci�:
Code Java : | S�lectionner tout |
1 2 3 4 | String texte = "texte � ins�rer � la fin du fichier"; try (FileWriter writer = new FileWriter("fichier.txt", true)) { writer.write(texte); } |
RandomAccessFile
Pour �crire � la fin de votre fichier binaire en utilisant la classe java.io.RandomAccessFile, vous devez d�placer le curseur � la fin du fichier en invoquant la m�thode seek() avant de tenter d'y �crire�:
Code Java : | S�lectionner tout |
1 2 3 4 5 | String texte = "texte � ins�rer � la fin du fichier"; try (RandomAccessFile file = new RandomAccessFile("fichier.bin", "rw")) { file.seek(file.length()); file.writeUTF(texte); } |
NIO2
Vous pouvez invoquer la m�thode statique write() de la classe utilitaire java.nio.file.Files en sp�cifiant les options StandardOpenOption.CREATE (pour cr�er le fichier s'il n'existe pas d�j�) et StandardOpenOption.APPEND (pour �crire � la fin du fichier s'il existe d�j�)�:
Code Java : | S�lectionner tout |
1 2 | String texte = "texte � ins�rer � la fin du fichier"; Files.write(Paths.get("fichier.txt"), texte.getBytes("utf-8"), StandardOpenOption.CREATE, StandardOpenOption.APPEND); |
-
Didacticiel : java.io par Anis Frikha.
De nombreux formats de fichiers texte peuvent �tre utilis�s avec Java. Malheureusement, tous ne sont pas utilisables gr�ce � l'API standard. Voici quelques formats et les API qui peuvent les utiliser�:
Format | API | Remarques |
HTML | API Standard | Cf. HTMLEditorKit, JEditorPane et JTextPane |
RTF | API Standard | Cf. RTFEditorKit, JEditorPane et JTextPane |
XML | API Standard (SAX, DOM) | Il existe de nombreuses biblioth�ques facilitant le travail avec ce type de documents |
iText, FOP | Ces deux biblioth�ques sont utilis�es seulement pour la g�n�ration | |
Excel | POI, JExcelAPI | |
Word | POI |
Proposer une nouvelle r�ponse sur la FAQ
Ce n'est pas l'endroit pour poser des questions, allez plut�t sur le forum de la rubrique pour �aLes sources pr�sent�es sur cette page sont libres de droits et vous pouvez les utiliser � votre convenance. Par contre, la page de pr�sentation constitue une �uvre intellectuelle prot�g�e par les droits d'auteur. Copyright � 2025 Developpez Developpez LLC. Tous droits r�serv�s Developpez LLC. Aucune reproduction, m�me partielle, ne peut �tre faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'� trois ans de prison et jusqu'� 300 000 � de dommages et int�r�ts.