FAQ Fichiers, flux et r�seauxConsultez toutes les FAQ

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.

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�:

1
2
3
4
try (InputStream input = new FileInputStream("fichier.txt") { 
    // Lecture du flux. 
    [...] 
}

1
2
3
4
try (InputStream input = Files.newInputStream(Paths.get("fichier.txt")) { 
    // Lecture du flux. 
    [...] 
}

1
2
3
4
try (OutputStream output = new FileOutputStream("fichier.txt") { 
    // �criture du flux. 
    [...] 
}

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�:

1
2
3
4
try (LineNumberReader reader = new LineNumberReader(new FileReader("fichier.txt"))) { 
    // Lecture du fichier texte. 
    [...] 
}

1
2
3
4
try (LineNumberReader reader = new LineNumberReader(Files.newBufferedReader(Paths.get("fichier.txt")))) { 
    // Lecture du fichier texte. 
    [...] 
}

1
2
3
4
try (PrintWriter writer = new PrintWriter(new FileWriter("fichier.txt"))) { 
    // �criture du fichier texte. 
    [...] 
}

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.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.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�:

1
2
3
4
try (RandomAccessFile file = new RandomAccessFile("fichier.bin", "r")) { 
    // Lecture du fichier. 
    [...] 
}

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.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�:

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. 
}

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(); 
    } 
}

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; 
    } 
}

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(); 
    } 
}

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. 
    } 
}

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; 
    } 
}

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). 
    } 
}

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().

1
2
3
4
// Imprime sur la sortie standard. 
System.out.println("Salut le monde�!"); 
// Imprime sur l'erreur standard. 
System.err.println("Erreur");

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.

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(); 
}

1
2
3
4
Scanner scanner = new Scanner(System.in); 
// Traitement. 
[...] 
scanner.close();

1
2
Console console = System.console(); 
String ligne = console.readLine();

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 :

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) :

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�:

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")) { 
            [...] 
        } 
    }  
}

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 :

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 :

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.

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()); 
}

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()); 
}

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.
  

• 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�:

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());  
}

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.
  

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.

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; 
}

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()); 
}

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()); 
}

• 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.
  

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()); 
}

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()); 
}

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�:

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()); 
}

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()); 
}

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()); 
}

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()); 
}

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()); 
}

� 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�:

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�:

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")); 
}

1
2
3
4
String texte = "texte � ins�rer � la fin du fichier"; 
try (FileWriter writer = new FileWriter("fichier.txt", true)) { 
    writer.write(texte); 
}

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); 
}

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);

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�: