Java - Fichiers et E/S

Le package java.io contient presque toutes les classes dont vous pourriez avoir besoin pour effectuer des entrées et des sorties (E/S) en Java. Tous ces flux représentent une source d'entrée et une destination de sortie. Le flux du package java.io prend en charge de nombreuses données telles que les primitives, les objets, les caractères localisés, etc.

Diffusion

Un flux peut être défini comme une séquence de données. Il existe deux types de flux −

InPutStream − L'InputStream est utilisé pour lire les données d'une source.
Flux de sortie − Le OutputStream est utilisé pour écrire des données vers une destination.

Java fournit une prise en charge solide mais flexible des E/S liées aux fichiers et aux réseaux, mais ce didacticiel couvre des fonctionnalités très basiques liées aux flux et aux E/S. Nous allons voir un à un les exemples les plus couramment utilisés −

Flux d'octets

Les flux d'octets Java sont utilisés pour effectuer l'entrée et la sortie d'octets 8 bits. Bien qu'il existe de nombreuses classes liées aux flux d'octets, les classes les plus fréquemment utilisées sont, FileInputStream et FileOutputStream . Voici un exemple qui utilise ces deux classes pour copier un fichier d'entrée dans un fichier de sortie −

Exemple

import java.io.*;
public class CopyFile {

   public static void main(String args[]) throws IOException {  
      FileInputStream in = null;
      FileOutputStream out = null;

      try {
         in = new FileInputStream("input.txt");
         out = new FileOutputStream("output.txt");
         
         int c;
         while ((c = in.read()) != -1) {
            out.write(c);
         }
      }finally {
         if (in != null) {
            in.close();
         }
         if (out != null) {
            out.close();
         }
      }
   }
}

Prenons maintenant un fichier input.txt avec le contenu suivant −

This is test for copy file.

Dans une prochaine étape, compilez le programme ci-dessus et exécutez-le, ce qui entraînera la création d'un fichier output.txt avec le même contenu que celui que nous avons dans input.txt. Mettons donc le code ci-dessus dans le fichier CopyFile.java et procédons comme suit −

$javac CopyFile.java
$java CopyFile

Flux de personnages

Java Octet les flux sont utilisés pour effectuer l'entrée et la sortie d'octets de 8 bits, alors que Java Character les flux sont utilisés pour effectuer l'entrée et la sortie pour l'unicode 16 bits. Bien qu'il existe de nombreuses classes liées aux flux de caractères, les classes les plus fréquemment utilisées sont, FileReader et FileWriter . Bien qu'en interne, FileReader utilise FileInputStream et FileWriter utilise FileOutputStream, mais ici la principale différence est que FileReader lit deux octets à la fois et FileWriter écrit deux octets à la fois.

Nous pouvons réécrire l'exemple ci-dessus, qui utilise ces deux classes pour copier un fichier d'entrée (ayant des caractères unicode) dans un fichier de sortie −

Exemple

import java.io.*;
public class CopyFile {

   public static void main(String args[]) throws IOException {
      FileReader in = null;
      FileWriter out = null;

      try {
         in = new FileReader("input.txt");
         out = new FileWriter("output.txt");
         
         int c;
         while ((c = in.read()) != -1) {
            out.write(c);
         }
      }finally {
         if (in != null) {
            in.close();
         }
         if (out != null) {
            out.close();
         }
      }
   }
}

Prenons maintenant un fichier input.txt avec le contenu suivant −

This is test for copy file.

$javac CopyFile.java
$java CopyFile

Flux standards

Tous les langages de programmation prennent en charge les E/S standard où le programme de l'utilisateur peut prendre une entrée à partir d'un clavier, puis produire une sortie sur l'écran de l'ordinateur. Si vous connaissez C ou C++; langages de programmation, alors vous devez connaître trois dispositifs standard STDIN, STDOUT et STDERR. De même, Java fournit les trois flux standard suivants −

Saisie standard − Ceci est utilisé pour fournir les données au programme de l'utilisateur et généralement un clavier est utilisé comme flux d'entrée standard et représenté comme System.in .
Sortie standard − Ceci est utilisé pour sortir les données produites par le programme de l'utilisateur et généralement un écran d'ordinateur est utilisé pour le flux de sortie standard et représenté comme System.out .
Erreur standard − Ceci est utilisé pour sortir les données d'erreur produites par le programme de l'utilisateur et généralement un écran d'ordinateur est utilisé pour le flux d'erreur standard et représenté comme System.err .

Voici un programme simple, qui crée InputStreamReader pour lire le flux d'entrée standard jusqu'à ce que l'utilisateur tape un "q" −

Exemple

Démo en direct

import java.io.*;
public class ReadConsole {

   public static void main(String args[]) throws IOException {
      InputStreamReader cin = null;

      try {
         cin = new InputStreamReader(System.in);
         System.out.println("Enter characters, 'q' to quit.");
         char c;
         do {
            c = (char) cin.read();
            System.out.print(c);
         } while(c != 'q');
      }finally {
         if (cin != null) {
            cin.close();
         }
      }
   }
}

Conservons le code ci-dessus dans le fichier ReadConsole.java et essayons de le compiler et de l'exécuter comme indiqué dans le programme suivant. Ce programme continue à lire et à sortir le même caractère jusqu'à ce que nous appuyions sur 'q' −

$javac ReadConsole.java
$java ReadConsole
Enter characters, 'q' to quit.
1
1
e
e
q
q

Lire et écrire des fichiers

Comme décrit précédemment, un flux peut être défini comme une séquence de données. Le flux d'entrée est utilisé pour lire les données d'une source et le OutputStream est utilisé pour écrire des données vers une destination.

Voici une hiérarchie de classes pour gérer les flux d'entrée et de sortie.

Les deux flux importants sont FileInputStream et FileOutputStream , dont il sera question dans ce didacticiel.

FileInputStream

Ce flux est utilisé pour lire les données des fichiers. Les objets peuvent être créés en utilisant le mot-clé nouveau et plusieurs types de constructeurs sont disponibles.

Le constructeur suivant prend un nom de fichier sous forme de chaîne pour créer un objet de flux d'entrée pour lire le fichier −

InputStream f = new FileInputStream("C:/java/hello");

Le constructeur suivant prend un objet de fichier pour créer un objet de flux d'entrée pour lire le fichier. Nous créons d'abord un objet fichier en utilisant la méthode File() comme suit −

File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);

Une fois que vous avez InputStream objet en main, il existe une liste de méthodes d'assistance qui peuvent être utilisées pour lire dans le flux ou pour effectuer d'autres opérations sur le flux.

public void close() lève IOException{}

Cette méthode ferme le flux de sortie du fichier. Libère toutes les ressources système associées au fichier. Lève une IOException.

protected void finalize() lance IOException {}

Cette méthode nettoie la connexion au fichier. Garantit que la méthode close de ce flux de sortie de fichier est appelée lorsqu'il n'y a plus de références à ce flux. Lève une IOException.

public int read(int r)lance IOException{}

Cette méthode lit l'octet de données spécifié à partir de InputStream. Renvoie un int. Renvoie l'octet de données suivant et -1 sera renvoyé s'il s'agit de la fin du fichier.

public int read(byte[] r) lance une exception IO{}

Cette méthode lit r.length octets du flux d'entrée dans un tableau. Renvoie le nombre total d'octets lus. S'il s'agit de la fin du fichier, -1 sera renvoyé.

public int available() lève IOException{}

Donne le nombre d'octets pouvant être lus à partir de ce flux d'entrée de fichier. Renvoie un int.

Sr.No.	Méthode et description
1
2
3
4
5

Il existe d'autres flux d'entrée importants disponibles, pour plus de détails, vous pouvez vous référer aux liens suivants −

ByteArrayInputStream
DataInputStream

FileOutputStream

FileOutputStream est utilisé pour créer un fichier et y écrire des données. Le flux créerait un fichier, s'il n'existe pas déjà, avant de l'ouvrir pour la sortie.

Voici deux constructeurs qui peuvent être utilisés pour créer un objet FileOutputStream.

Le constructeur suivant prend un nom de fichier sous forme de chaîne pour créer un objet de flux d'entrée pour écrire le fichier −

OutputStream f = new FileOutputStream("C:/java/hello")

Le constructeur suivant prend un objet fichier pour créer un objet flux de sortie pour écrire le fichier. Tout d'abord, nous créons un objet fichier en utilisant la méthode File() comme suit −

File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);

Une fois que vous avez OutputStream objet en main, il existe une liste de méthodes d'assistance, qui peuvent être utilisées pour écrire dans le flux ou pour effectuer d'autres opérations sur le flux.

public void close() lève IOException{}

Cette méthode ferme le flux de sortie du fichier. Libère toutes les ressources système associées au fichier. Lève une IOException.

protected void finalize() lance IOException {}

Cette méthode nettoie la connexion au fichier. Garantit que la méthode close de ce flux de sortie de fichier est appelée lorsqu'il n'y a plus de références à ce flux. Lève une IOException.

public void write(int w)throws IOException{}

Cette méthode écrit l'octet spécifié dans le flux de sortie.

public void write(byte[] w)

Écrit w.length octets du tableau d'octets mentionné dans OutputStream.

Sr.No.	Méthode et description
1
2
3
4

Il existe d'autres flux de sortie importants disponibles, pour plus de détails, vous pouvez vous référer aux liens suivants −

ByteArrayOutputStream
DataOutputStream

Exemple

Voici l'exemple pour démontrer InputStream et OutputStream −

import java.io.*;
public class fileStreamTest {

   public static void main(String args[]) {
   
      try {
         byte bWrite [] = {11,21,3,40,5};
         OutputStream os = new FileOutputStream("test.txt");
         for(int x = 0; x < bWrite.length ; x++) {
            os.write( bWrite[x] );   // writes the bytes
         }
         os.close();
     
         InputStream is = new FileInputStream("test.txt");
         int size = is.available();

         for(int i = 0; i < size; i++) {
            System.out.print((char)is.read() + "  ");
         }
         is.close();
      } catch (IOException e) {
         System.out.print("Exception");
      }	
   }
}

Le code ci-dessus créerait un fichier test.txt et écrirait des nombres donnés au format binaire. La même chose serait la sortie sur l'écran stdout.

Navigation de fichiers et E/S

Il existe plusieurs autres cours que nous suivrions pour connaître les bases de la navigation dans les fichiers et des E/S.

Classe de fichier
Classe FileReader
Classe FileWriter

Répertoires en Java

Un répertoire est un fichier qui peut contenir une liste d'autres fichiers et répertoires. Vous utilisez Fichier objet pour créer des répertoires, pour lister les fichiers disponibles dans un répertoire. Pour plus de détails, consultez une liste de toutes les méthodes que vous pouvez appeler sur l'objet File et celles qui sont liées aux répertoires.

Créer des répertoires

Il existe deux fichiers utiles méthodes utilitaires, qui peuvent être utilisées pour créer des répertoires −

Le mkdir( ) La méthode crée un répertoire, retournant true en cas de succès et false en cas d'échec. Un échec indique que le chemin spécifié dans l'objet File existe déjà ou que le répertoire ne peut pas être créé car le chemin complet n'existe pas encore.
Les mkdirs() La méthode crée à la fois un répertoire et tous les parents du répertoire.

L'exemple suivant crée le répertoire "/tmp/user/java/bin" −

Exemple

import java.io.File;
public class CreateDir {

   public static void main(String args[]) {
      String dirname = "/tmp/user/java/bin";
      File d = new File(dirname);
      
      // Create directory now.
      d.mkdirs();
   }
}

Compilez et exécutez le code ci-dessus pour créer "/tmp/user/java/bin".

Remarque − Java prend automatiquement en charge les séparateurs de chemin sous UNIX et Windows selon les conventions. Si vous utilisez une barre oblique (/) sur une version Windows de Java, le chemin sera toujours résolu correctement.

Liste des répertoires

Vous pouvez utiliser list( ) méthode fournie par Fichier objet pour lister tous les fichiers et répertoires disponibles dans un répertoire comme suit −

Exemple

import java.io.File;
public class ReadDir {

   public static void main(String[] args) {
      File file = null;
      String[] paths;
  
      try {      
         // create new file object
         file = new File("/tmp");

         // array of files and directory
         paths = file.list();

         // for each name in the path array
         for(String path:paths) {
            // prints filename and directory name
            System.out.println(path);
         }
      } catch (Exception e) {
         // if any error occurs
         e.printStackTrace();
      }
   }
}

Cela produira le résultat suivant basé sur les répertoires et fichiers disponibles dans votre /tmp répertoire −

Sortie

test1.txt
test2.txt
ReadDir.java
ReadDir.class

Java - Méthodes Java - Exceptions

Java