Developpez.com - Java
X

Choisissez d'abord la catégorieensuite la rubrique :

 

Développons en Java   2.10  
Copyright (C) 1999-2016 Jean-Michel DOUDOUX    (date de publication : 19/03/2016)

[ Précédent ] [ Sommaire ] [ Suivant ] [Télécharger ]      [Accueil ]

 

13. Les flux

 

chapitre 1 3

 

Niveau : niveau 3 Intermédiaire 

 

Un programme a souvent besoin d'échanger des informations, que ce soit pour recevoir des données d'une source ou pour envoyer des données vers un destinataire.

La source et la destination de ces échanges peuvent être de natures multiples : un fichier, une socket réseau, un autre programme, etc ...

De la même façon, la nature des données échangées peut être diverse : du texte, des images, du son, etc ...

Ce chapitre contient plusieurs sections :

 

13.1. La présentation des flux

Les flux (streams en anglais) permettent d'encapsuler ces processus d'envoi et de réception de données. Les flux traitent toujours les données de façon séquentielle.

En Java, les flux peuvent être divisés en plusieurs catégories :

Java définit des flux pour lire ou écrire des données mais aussi des classes qui permettent de faire des traitements sur les données du flux. Ces classes doivent être associées à un flux de lecture ou d'écriture et sont considérées comme des filtres. Par exemple, il existe des filtres qui permettent de mettre les données traitées dans un tampon (buffer) pour les traiter par lots.

Toutes ces classes sont regroupées dans le package java.io.

 

13.2. Les classes de gestion des flux

Ce qui déroute dans l'utilisation de ces classes, c'est leur nombre et la difficulté de choisir celle qui convient le mieux en fonction des besoins. Pour faciliter ce choix, il faut comprendre la dénomination des classes : cela permet de sélectionner la ou les classes adaptées aux traitements à réaliser.

Le nom des classes se compose d'un préfixe et d'un suffixe. Il y a quatre suffixes possibles en fonction du type de flux (flux d'octets ou de caractères) et du sens du flux (entrée ou sortie).

  Flux d'octets Flux de caractères
Flux d'entrée InputStream Reader
Flux de sortie OutputStream Writer

Il existe donc quatre hiérarchies de classes qui encapsulent des types de flux particuliers. Ces classes peuvent être séparées en deux séries de deux catégories différentes : les classes de lecture et d'écriture et les classes permettant la lecture de caractères ou d'octets.

Pour le préfixe, il faut distinguer les flux et les filtres. Pour les flux, le préfixe contient la source ou la destination selon le sens du flux.

Préfixe du flux source ou destination du flux
ByteArray tableau d'octets en mémoire
CharArray tableau de caractères en mémoire
File fichier
Object objet
Pipe pipeline entre deux threads
String chaîne de caractères

Pour les filtres, le préfixe contient le type de traitement qu'il effectue. Les filtres n'existent pas obligatoirement pour des flux en entrée et en sortie.

Type de traitement Préfixe de la classe En entrée En sortie
Mise en tampon Buffered Oui Oui
Concaténation de flux Sequence Oui pour flux d'octets Non
Conversion de données Data Oui pour flux d'octets Oui pour flux d'octets
Numérotation des lignes LineNumber Oui pour les flux de caractères Non
Lecture avec remise dans le flux des données PushBack Oui Non
Impression Print Non Oui
Sérialisation Object Oui pour flux d'octets Oui pour flux d'octets
Conversion octets/caractères InputStream / OutputStream Oui pour flux d'octets Oui pour flux d'octets

La package java.io définit ainsi plusieurs classes :

  Flux en lecture Flux en sortie
Flux de caractères

BufferedReader

CharArrayReader

FileReader

InputStreamReader

LineNumberReader

PipedReader

PushbackReader

StringReader

BufferedWriter

CharArrayWriter

FileWriter

OutputStreamWriter

 

PipedWriter

 

StringWriter

Flux d'octets

BufferedInputStream

ByteArrayInputStream

DataInputStream

FileInputStream

ObjectInputStream

PipedInputStream

 

PushbackInputStream

SequenceInputStream

BufferedOutputStream

ByteArrayOutputStream

DataOuputStream

FileOutputStream

ObjetOutputStream

PipedOutputStream

PrintStream

 

13.3. Les flux de caractères

Ils transportent des données sous forme de caractères : Java les gèrent avec le format Unicode qui code les caractères sur 2 octets.

Ce type de flux a été ajouté à partir du JDK 1.1.

Les classes qui gèrent les flux de caractères héritent d'une des deux classes abstraites Reader ou Writer. Il existe de nombreuses sous-classes pour traiter les flux de caractères.

 

13.3.1. La classe Reader

C'est une classe abstraite qui est la classe mère de toutes les classes qui gèrent des flux de caractères en lecture.

Cette classe définit plusieurs méthodes :

Méthodes Rôles
boolean markSupported() indique si le flux supporte la possibilité de marquer des positions
boolean ready() indique si le flux est prêt à être lu
close() ferme le flux et libère les ressources qui lui étaient associées
int read() renvoie le caractère lu ou -1 si la fin du flux est atteinte.
int read(char[]) lire plusieurs caractères et les mettre dans un tableau de caractères
int read(char[], int, int) lire plusieurs caractères. Elle attend en paramètre : un tableau de caractères qui contiendra les caractères lus, l'indice du premier élément du tableau qui recevra le premier caractère et le nombre de caractères à lire. Elle renvoie le nombre de caractères lus ou -1 si aucun caractère n'a été lu. Le tableau de caractères contient les caractères lus.
long skip(long) saute autant de caractères dans le flux que la valeur fournie en paramètre. Elle renvoie le nombre de caractères sautés.
mark() permet de marquer une position dans le flux
reset() retourne dans le flux à la dernière position marquée

 

13.3.2. La classe Writer

C'est une classe abstraite qui est la classe mère de toutes les classes qui gèrent des flux de caractères en écriture.

Cette classe définit plusieurs méthodes :

Méthodes Rôles
close() ferme le flux et libère les ressources qui lui étaient associées
write(int) écrire le caractère en paramètre dans le flux.
write(char[]) écrire le tableau de caractères en paramètre dans le flux.
write(char[], int, int) écrire plusieurs caractères. Elle attend en paramètres : un tableau de caractères, l'indice du premier caractère et le nombre de caractères à écrire.
write(String) écrire la chaîne de caractères en paramètre dans le flux
write(String, int, int) écrire une portion d'une chaîne de caractères. Elle attend en paramètre : une chaîne de caractères, l'indice du premier caractère et le nombre de caractères à écrire.

 

13.3.3. Les flux de caractères avec un fichier

Les classes FileReader et FileWriter permettent de gérer des flux de caractères avec des fichiers.

 

13.3.3.1. Les flux de caractères en lecture sur un fichier

Il faut instancier un objet de la classe FileReader. Cette classe hérite de la classe InputStreamReader et possède plusieurs constructeurs qui peuvent tous lever une exception de type FileNotFoundException:

Constructeur Rôle
FileInputReader(String) Créer un flux en lecture vers le fichier dont le nom est précisé en paramètre.
FileInputReader(File) Idem mais le fichier est précisé avec un objet de type File

Exemple ( code Java 1.1 ) :
FileReader fichier = new FileReader("monfichier.txt");

Il existe plusieurs méthodes de la classe FileReader qui permettent de lire un ou plusieurs caractères dans le flux. Toutes ces méthodes sont héritées de la classe Reader et peuvent toutes lever l'exception IOException.

Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().

 

13.3.3.2. Les flux de caractères en écriture sur un fichier

Il faut instancier un objet de la classe FileWriter qui hérite de la classe OuputStreamWriter. Cette classe possède plusieurs constructeurs :

Constructeur Rôle
FileWriter(String) Si le nom du fichier précisé n'existe pas alors le fichier sera créé. S'il existe et qu'il contient des données celles-ci seront écrasées
FileWriter(File) Idem mais le fichier est précisé avec un objet de la classe File
FileWriter(String, boolean) Le booléen permet de préciser si les données seront ajoutées au fichier (valeur true) ou écraseront les données existantes (valeur false)

Exemple ( code Java 1.1 ) :
FileWriter fichier = new FileWriter ("monfichier.dat");

Il existe plusieurs méthodes de la classe FileWriter héritées de la classe Writer qui permettent d'écrire un ou plusieurs caractères dans le flux.

Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().

 

13.3.4. Les flux de caractères tamponnés avec un fichier.

Pour améliorer les performances des flux sur un fichier, la mise en tampon des données lues ou écrites permet de traiter un ensemble de caractères représentant une ligne plutôt que de traiter les données caractères par caractères. Le nombre d'opérations est ainsi réduit.

Les classes BufferedReader et BufferedWriter permettent de gérer des flux de caractères tamponnés avec des fichiers.

 

13.3.4.1. Les flux de caractères tamponnés en lecture avec un fichier

Il faut instancier un objet de la classe BufferedReader. Cette classe possède plusieurs constructeurs qui peuvent tous lever une exception de type FileNotFoundException:

Constructeur Rôle
BufferedReader(Reader) le paramètre fourni doit correspondre au flux à lire.
BufferedReader(Reader, int) l'entier en paramètre permet de préciser la taille du buffer. Il doit être positif sinon une exception de type IllegalArgumentException est levée.

Exemple ( code Java 1.1 ) :
BufferedReader fichier  = new BufferedReader(new FileReader("monfichier.txt"));

Il existe plusieurs méthodes de la classe BufferedReader héritées de la classe Reader qui permettent de lire un ou plusieurs caractères dans le flux. Toutes ces méthodes peuvent lever une exception de type IOException. La classe BufferedReader définit une méthode supplémentaire pour la lecture :

Méthode Rôle
String readLine() lire une ligne de caractères dans le flux. Une ligne est une suite de caractères qui se termine par un retour chariot '\r' ou un saut de ligne '\n' ou les deux.

Elle possède plusieurs méthodes pour gérer le flux hérité de la classe Reader.

Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().

Exemple ( code Java 1.1 ) :
import java.io.*;

public class TestBufferedReader {
  protected String source;
  
  public TestBufferedReader(String source) {
    this.source = source;
    lecture();
  }

  public static void main(String args[]) {
    new TestBufferedReader("source.txt");
  }

  private void lecture() { 
    try {
      String ligne ;
      BufferedReader fichier = new BufferedReader(new FileReader(source));
      
      while ((ligne = fichier.readLine()) != null) {
          System.out.println(ligne);
      }

      fichier.close();
    } catch (Exception e) {
      e.printStackTrace();
    }     
  }    
}

 

13.3.4.2. Les flux de caractères tamponnés en écriture avec un fichier

Il faut instancier un objet de la classe BufferedWriter. Cette classe possède plusieurs constructeurs :

Constructeur Rôle
BufferedWriter(Writer) le paramètre fourni doit correspondre au flux dans lequel les données sont écrites.
BufferedWriter(Writer, int) l'entier en paramètre permet de préciser la taille du buffer. Il doit être positif sinon une exception IllegalArgumentException est levée.

Exemple ( code Java 1.1 ) :
BufferedWriter fichier = new BufferedWriter( new FileWriter("monfichier.txt"));

Il existe plusieurs méthodes de la classe BufferedWriter héritées de la classe Writer qui permettent de lire un ou plusieurs caractères dans le flux.

La classe BufferedWriter possède plusieurs méthodes pour gérer le flux :

Méthode Rôle
flush() vide le tampon en écrivant les données dans le flux.
newLine() écrire un séparateur de ligne dans le flux

Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().

Exemple ( code Java 1.1 ) :
import java.io.*;
import java.util.*;

public class TestBufferedWriter {
  protected String destination;
  
  public TestBufferedWriter(String destination) {
    this.destination = destination;
    traitement();
  }

  public static void main(String args[]) {
    new TestBufferedWriter("print.txt");
  }

  private void traitement() { 
    try {
      String ligne ;
      int nombre = 123;
      BufferedWriter fichier = new BufferedWriter(new FileWriter(destination));

      fichier.write("bonjour tout le monde");
      fichier.newLine();
      fichier.write("Nous sommes le "+ new Date());      
      fichier.write(", le nombre magique est " + nombre);

      fichier.close();
    } catch (Exception e) {
      e.printStackTrace();
    }     
  }    
}

 

13.3.4.3. La classe PrintWriter

Cette classe permet d'écrire dans un flux des données formatées.

Cette classe possède plusieurs constructeurs :

Constructeur Rôle
PrintWriter(Writer) Le paramètre fourni précise le flux. Le tampon est automatiquement vidé.
PrintWriter(Writer, boolean) Le booléen permet de préciser si le tampon doit être automatiquement vidé
PrintWriter(OutputStream) Le paramètre fourni précise le flux. Le tampon est automatiquement vidé.
PrintWriter(OutputStream, boolean) Le booléen permet de préciser si le tampon doit être automatiquement vidé

Exemple ( code Java 1.1 ) :
PrintWriter fichier = new PrintWriter( new FileWriter("monfichier.txt"));

Il existe de nombreuses méthodes de la classe PrintWriter qui permettent d'écrire un ou plusieurs caractères dans le flux en les formatant. Les méthodes write() sont héritées de la classe Writer qui définit plusieurs méthodes pour envoyer des données formatées dans le flux :

La classe PrintWriter possède plusieurs méthodes pour gérer le flux :

Méthode Rôle
close() Ferme le tampon et libérer les ressources associées
boolean checkError() Vide le tampon et renvoie true si une exception est levée lors de l'utilisation du flux sous-jacent
flush() Vide le tampon en écrivant les données dans le flux.

Exemple ( code Java 1.1 ) :
import java.io.*;
import java.util.*;

public class TestPrintWriter {
  protected String destination;
  
  public TestPrintWriter(String destination) {
    this.destination = destination;
    traitement();
  }

  public static void main(String args[]) {
    new TestPrintWriter("print.txt");
  }

  private void traitement() { 
    try {
      String ligne ;
      int nombre = 123;
      PrintWriter fichier = new PrintWriter(new FileWriter(destination));

      fichier.println("bonjour tout le monde");
      fichier.println("Nous sommes le "+ new Date());      
      fichier.println("le nombre magique est " + nombre);

      fichier.close();
    } catch (Exception e) {
      e.printStackTrace();
    }     
  }    
}

 

13.4. Les flux d'octets

Ils transportent des données sous forme d'octets. Les flux de ce type sont capables de traiter toutes les données.

Les classes qui gèrent les flux d'octets héritent d'une des deux classes abstraites InputStream ou OutputStream. Il existe de nombreuses sous-classes pour traiter les flux d'octets.

 

13.4.1. Les flux d'octets avec un fichier.

Les classes FileInputStream et FileOutputStream permettent de gérer des flux d'octets avec des fichiers.

 

13.4.1.1. Les flux d'octets en lecture sur un fichier

Il faut instancier un objet de la classe FileInputStream. Cette classe possède plusieurs constructeurs qui peuvent tous lever l'exception FileNotFoundException:

Constructeur Rôle
FileInputStream(String) Ouvre un flux en lecture sur le fichier dont le nom est donné en paramètre
FileInputStream(File) Idem mais le fichier est précisé avec un objet de type File

Exemple ( code Java 1.1 ) :
FileInputStream fichier = new FileInputStream("monfichier.dat");

Il existe plusieurs méthodes de la classe FileInputStream qui permettent de lire un ou plusieurs octets dans le flux. Toutes ces méthodes peuvent lever l'exception IOException.

La classe FileInputStream possède plusieurs méthodes pour gérer le flux :

Méthode Rôle
long skip(long) saute autant d'octets dans le flux que la valeur fournie en paramètre. Elle renvoie le nombre d'octets sautés.
close() ferme le flux et libère les ressources qui lui étaient associées
int available() retourne une estimation du nombre d'octets qu'il est encore possible de lire dans le flux

Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().

 

13.4.1.2. Les flux d'octets en écriture sur un fichier

Il faut instancier un objet de la classe FileOutputStream. Cette classe possède plusieurs constructeurs :

Constructeur Rôle
FileOutputStream(String) Si le fichier précisé n'existe pas, il sera créé. Si il existe et qu'il contient des données celles-ci seront écrasées.
FileOutputStream(String, boolean) Le booléen permet de préciser si les données seront ajoutées au fichier (valeur true) ou écraseront les données existantes (valeur false)

Exemple ( code Java 1.1 ) :
FileOuputStream fichier = new FileOutputStream("monfichier.dat");

Il existe plusieurs méthodes de la classe FileOutputStream qui permettent d'écrire un ou plusieurs octets dans le flux.

Méthode Rôle
write(int) Cette méthode écrit l'octet en paramètre dans le flux
write(byte[]) Cette méthode écrit plusieurs octets. Elle attend en paramètre : un tableau d'octets qui contient les octets à écrire : tous les éléments du tableau sont écrits
write(byte[], int, int) Cette méthode écrit plusieurs octets. Elle attend en paramètre : un tableau d'octets qui contient les octets à écrire, l'indice du premier élément du tableau d'octets à écrire et le nombre d'octets à écrire

Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().

Exemple ( code Java 1.1 ) :
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopieFichier {

  public static void main(String args[]) {
    try {
      copierFichier("source.txt", "copie.txt");
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  public static void copierFichier(String source, String destination) throws IOException {
    FileInputStream fis = null;
    FileOutputStream fos = null;

    try {
      byte buffer[] = new byte[1024];
      int taille = 0;

      fis = new FileInputStream(source);
      fos = new FileOutputStream(destination);
      while ((taille = fis.read(buffer)) != -1) {
        System.out.println(taille);
        fos.write(buffer, 0, taille);
      }
    } finally {
      if (fis != null) {
        try {
          fis.close();
        } catch (IOException e) {
        }
      }
      if (fos != null) {
        try {
          fos.close();
        } catch (IOException e) {
        }
      }
    }
  }
}

Remarque : cet exemple est fourni à titre indicatif pour démontrer l'utilisation de l'API. Il est préférable d'utiliser l'API Apache Commons IO ou la méthode copy() de la classe Files de Java 7 plutôt que de réécrire une méthode de copie d'un fichier.

 

13.4.2. Les flux d'octets tamponnés avec un fichier.

Pour améliorer les performances des flux sur un fichier, la mise en tampon des données lues ou écrites permet de traiter un ensemble d'octets plutôt que de traiter les données octet par octet. Le nombre d'opérations est ainsi réduit.

 

13.5. La classe File

Les fichiers et les répertoires sont encapsulés dans la classe File du package java.io. Il n'existe pas de classe pour traiter les répertoires car ils sont considérés comme des fichiers. Une instance de la classe File est une représentation logique d'un fichier ou d'un répertoire qui peut ne pas exister physiquement sur le disque.

Si le fichier ou le répertoire existe, de nombreuses méthodes de la classe File permettent d'obtenir des informations sur le fichier. Sinon plusieurs méthodes permettent de créer des fichiers ou des répertoires. Voici une liste des principales méthodes :

Méthode Rôle
boolean canRead() Indiquer si le fichier peut être lu
boolean canWrite() Indiquer si le fichier peut être modifié
boolean createNewFile() a partir de Java 1.2Créer un nouveau fichier vide
File createTempFile(String, String) a partir de Java 1.2Créer un nouveau fichier dans le répertoire par défaut des fichiers temporaires. Les deux arguments sont le nom et le suffixe du fichier
File createTempFile(String, String, File) Créer un nouveau fichier temporaire. Les trois arguments sont le nom, le suffixe du fichier et le répertoire
boolean delete() Détruire le fichier ou le répertoire. Le booléen indique le succès de l'opération
deleteOnExit() a partir de Java 1.2 Demander la suppression du fichier à l'arrêt de la JVM
boolean exists() Indique si le fichier existe physiquement
String getAbsolutePath() Renvoyer le chemin absolu du fichier
String getPath Renvoyer le chemin du fichier
boolean isAbsolute() Indiquer si le chemin est absolu
boolean isDirectory() Indiquer si le fichier est un répertoire
boolean isFile() Indiquer si l'objet représente un fichier
long length() Renvoyer la longueur du fichier
String[] list() Renvoyer la liste des fichiers et répertoires contenus dans le répertoire
boolean mkdir() Créer le répertoire
boolean mkdirs() Créer le répertoire avec création des répertoires manquants dans l'arborescence du chemin
boolean renameTo() Renommer le fichier

Depuis la version 1.2 du J.D.K., de nombreuses fonctionnalités ont été ajoutées à cette classe :

Exemple ( code Java 1.1 ) :
import java.io.*;

public class TestFile {
  protected String nomFichier;
  protected File fichier;
  
  public TestFile(String nomFichier) {
    this.nomFichier = nomFichier;
    fichier = new File(nomFichier);
    traitement();
  }

  public static void main(String args[]) {
    new TestFile(args[0]);
  }

  private void traitement() {

    if (!fichier.exists()) { 
      System.out.println("le fichier "+nomFichier+" n'existe pas");
      System.exit(1);
    }      
     
    System.out.println(" Nom du fichier    : "+fichier.getName());
    System.out.println(" Chemin du fichier : "+fichier.getPath());
    System.out.println(" Chemin absolu     : "+fichier.getAbsolutePath());
    System.out.println(" Droit de lecture  : "+fichier.canRead()); 
    System.out.println(" Droit d'ecriture  : "+fichier.canWrite());
    
    if (fichier.isDirectory() ) {
      System.out.println(" contenu du repertoire ");
      String fichiers[] = fichier.list();
      for(int i = 0; i > fichiers.length; i++) System.out.println("  "+fichiers[i]);
    }     
  }			
}
Exemple ( code Java 1.2 ) :
import java.io.*;

public class TestFile_12 {
  protected String nomFichier;
  protected File fichier;
  
  public TestFile_12(String nomFichier) {
    this.nomFichier = nomFichier;
    fichier = new File(nomFichier);
    traitement();
  }

  public static void main(String args[]) {
    new TestFile_12(args[0]);
  }

  private void traitement() {

    if (!fichier.exists()) { 
      System.out.println("le fichier "+nomFichier+"n'existe pas");
      System.exit(1);
    }      
     
    System.out.println(" Nom du fichier    : "+fichier.getName());
    System.out.println(" Chemin du fichier : "+fichier.getPath());
    System.out.println(" Chemin absolu     : "+fichier.getAbsolutePath());
    System.out.println(" Droit de lecture  : "+fichier.canRead()); 
    System.out.println(" Droit d'ecriture  : "+fichier.canWrite());
    
    if (fichier.isDirectory() ) {
      System.out.println(" contenu du repertoire ");
      File fichiers[] = fichier.listFiles();
      for(int i = 0; i > fichiers.length; i++) {
      	
      	if (fichiers[i].isDirectory()) 
      	  System.out.println("  ["+fichiers[i].getName()+"]");      	
      	else
      	  System.out.println("  "+fichiers[i].getName());
      }
    }     
  }			
}

 

13.6. Les fichiers à accès direct

Les fichiers à accès direct permettent un accès rapide à un enregistrement contenu dans un fichier. Le plus simple pour utiliser un tel type de fichier est qu'il contienne des enregistrements de taille fixe mais ce n'est pas obligatoire. Il est possible dans un tel type de fichier de mettre à jour directement un de ses enregistrements.

La classe RamdonAccessFile encapsule les opérations de lecture/écriture d'un tel fichier. Elle implémente les interfaces DataInput et DataOutput.

Elle possède deux constructeurs qui attendent en paramètres le fichier à utiliser (sous la forme d'un nom de fichier ou d'un objet de type File qui encapsule le fichier) et le mode d'accès.

Le mode est une chaîne de caractères qui doit être égale à «r» ou «rw» selon que le mode est lecture seule ou lecture/écriture.

Ces deux constructeurs peuvent lever les exceptions suivantes :

La classe RandomAccessFile possède de nombreuses méthodes writeXXX() pour écrire des types primitifs dans le fichier.

Exemple :
package com.jmdoudoux.test;

import java.io.RandomAccessFile;

public class TestRandomAccesFile {
  public static void main(String[] args) {
    try {
      RandomAccessFile monFichier = new RandomAccessFile("monfichier.dat", "rw");
      for (int i = 0; i < 10; i++) {
        monFichier.writeInt(i * 100);
      }
      monFichier.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Elle possède aussi de nombreuses classes readXXX() pour lire des données primitives dans le fichier.

Exemple :
package com.jmdoudoux.test;

import java.io.RandomAccessFile;

public class TestRandomAccesFile {
  public static void main(String[] args) {
    try {
      RandomAccessFile monFichier = new RandomAccessFile("monfichier.dat", "rw");
      for (int i = 0; i < 10; i++) {
         System.out.println(monFichier.readInt());
      }
      monFichier.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Résultat :
  0
  100
  200
  300
  400
  500
  600
  700
  800
  900

Pour naviguer dans le fichier, la classe utilise un pointeur qui indique la position dans le fichier où les opérations de lecture ou de mise à jour doivent être effectuées. La méthode getFilePointer() permet de connaître la position de ce pointeur et la méthode seek() permet de le déplacer.

La méthode seek() attend en paramètre un entier long qui réprésente la position, dans le fichier, précisée en octets. La première position commence à zéro.

Exemple : lecture de la sixième données
package com.jmdoudoux.test;

import java.io.RandomAccessFile;

public class TestRandomAccesFile {
  public static void main(String[] args) {
    try {
      RandomAccessFile monFichier = new RandomAccessFile("monfichier.dat", "rw");
      // 5 représente le sixième enregistement puisque le premier commence à 0

      // 4 est la taille des données puisqu'elles sont des entiers de type int 

      // (codé sur 4 octets)

      monFichier.seek(5*4);
      System.out.println(monFichier.readInt());
      monFichier.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}
Résultat :
500

 

13.7. La classe java.io.Console

La classe java.io.Console, ajoutée dans Java SE 6, permet un accès à la console du système d'exploitation pour permettre la saisie ou l'affichage de données. Cette nouvelle classe fait usage des flux de type Reader et Writer ce qui permet une gestion correcte des caractères.

La classe System possède une méthode console() qui permet d'obtenir une instance de la classe Console.

La méthode printf() permet de formater et d'afficher des données.

La méthode readLine() permet la saisie d'une ligne de données dont les caractères sont affichés sur la console.

La méthode readPassword() est identique à la méthode readLine() mais les caractères saisis ne sont pas affichés sur la console.

Exemple :
package com.jmdoudoux.test.java6;

public class TestConsole {
    
        public static void main(String args[]) {
            String string = "La façade nécessaire";
            System.out.println(string);
            System.console().printf("%s%n", string);
    }
    
}
Résultat :
C:\java\TestJava6\classes>java com.jmdoudoux.test.java6.TestConsole
La faþade nÚcessaire
La façade nécessaire

 

 


[ Précédent ] [ Sommaire ] [ Suivant ] [Télécharger ]      [Accueil ]

72 commentaires Donner une note à l'article (5)

 

Copyright (C) 1999-2016 Jean-Michel DOUDOUX. Vous pouvez copier, redistribuer et/ou modifier ce document selon les termes de la Licence de Documentation Libre GNU, Version 1.1 ou toute autre version ultérieure publiée par la Free Software Foundation; les Sections Invariantes étant constitués du chapitre Préambule, aucun Texte de Première de Couverture, et aucun Texte de Quatrième de Couverture. Une copie de la licence est incluse dans la section GNU FreeDocumentation Licence. La version la plus récente de cette licence est disponible à l'adresse : GNU Free Documentation Licence.

Responsables bénévoles de la rubrique Java : Mickael Baron - Robin56 -