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 :