Classe Java FileInputStream

Dans ce didacticiel, nous allons découvrir Java FileInputStream et ses méthodes à l'aide d'exemples.

Le FileInputStream classe du java.io package peut être utilisé pour lire des données (en octets) à partir de fichiers.

Il étend le InputStream classe abstraite.

Avant d'en savoir plus sur FileInputStream , assurez-vous de connaître les fichiers Java.

Créer un FileInputStream

Afin de créer un flux d'entrée de fichier, nous devons importer le java.io.FileInputStream paquet d'abord. Une fois le package importé, voici comment créer un flux d'entrée de fichier en Java.

1. Utilisation du chemin d'accès au fichier

FileInputStream input = new FileInputStream(stringPath);

Ici, nous avons créé un flux d'entrée qui sera lié au fichier spécifié par le path .

2. Utiliser un objet du fichier

FileInputStream input = new FileInputStream(File fileObject);

Ici, nous avons créé un flux d'entrée qui sera lié au fichier spécifié par fileObject .

Méthodes de FileInputStream

Le FileInputStream la classe fournit des implémentations pour différentes méthodes présentes dans le InputStream classe.

méthode read()

read() - lit un seul octet du fichier
read(byte[] array) - lit les octets du fichier et les stocke dans le tableau spécifié
read(byte[] array, int start, int length) - lit le nombre d'octets égal à longueur à partir du fichier et stocke dans le tableau spécifié à partir de la position début

Supposons que nous ayons un fichier nommé input.txt avec le contenu suivant.

This is a line of text inside the file.

Essayons de lire ce fichier en utilisant FileInputStream .

import java.io.FileInputStream;

public class Main {

  public static void main(String args[]) {

     try {
        FileInputStream input = new FileInputStream("input.txt");

        System.out.println("Data in the file: ");

        // Reads the first byte
        int i = input.read();

       while(i != -1) {
           System.out.print((char)i);

           // Reads next byte from the file
           i = input.read();
        }
        input.close();
     }

     catch(Exception e) {
        e.getStackTrace();
     }
  }
}

Sortie

Data in the file:
This is a line of text inside the file.

Dans l'exemple ci-dessus, nous avons créé un flux d'entrée de fichier nommé input . Le flux d'entrée est lié au input.txt fichier.

FileInputStream input = new FileInputStream("input.txt");

Pour lire les données du fichier, nous avons utilisé le read() méthode à l'intérieur de la boucle while.

méthode available()

Pour obtenir le nombre d'octets disponibles, nous pouvons utiliser le available() méthode. Par exemple,

import java.io.FileInputStream;

public class Main {

   public static void main(String args[]) {

      try {
         // Suppose, the input.txt file contains the following text
         // This is a line of text inside the file.
         FileInputStream input = new FileInputStream("input.txt");

         // Returns the number of available bytes
         System.out.println("Available bytes at the beginning: " + input.available());

         // Reads 3 bytes from the file
         input.read();
         input.read();
         input.read();

         // Returns the number of available bytes
         System.out.println("Available bytes at the end: " + input.available());

         input.close();
      }

      catch (Exception e) {
         e.getStackTrace();
      }
   }
}

Sortie

Available bytes at the beginning: 39
Available bytes at the end: 36

Dans l'exemple ci-dessus,

Nous utilisons d'abord le available() méthode pour vérifier le nombre d'octets disponibles dans le flux d'entrée du fichier.
Nous avons alors utilisé le read() méthode 3 fois pour lire 3 octets du flux d'entrée du fichier.
Maintenant, après avoir lu les octets, nous avons de nouveau vérifié les octets disponibles. Cette fois, les octets disponibles ont diminué de 3.

Méthode skip()

Pour ignorer et ignorer le nombre d'octets spécifié, nous pouvons utiliser le skip() méthode. Par exemple,

import java.io.FileInputStream;

public class Main {

   public static void main(String args[]) {

      try {
         // Suppose, the input.txt file contains the following text
         // This is a line of text inside the file.
         FileInputStream input = new FileInputStream("input.txt");

         // Skips the 5 bytes
         input.skip(5);
         System.out.println("Input stream after skipping 5 bytes:");

         // Reads the first byte
         int i = input.read();
         while (i != -1) {
            System.out.print((char) i);

            // Reads next byte from the file
            i = input.read();
         }

         // close() method
         input.close();
      }
      catch (Exception e) {
         e.getStackTrace();
      }
   }
}

Sortie

Input Stream after skipping 5 bytes:
is a line of text inside the file.

Dans l'exemple ci-dessus, nous avons utilisé le skip() méthode pour ignorer 5 octets de données du flux d'entrée du fichier. Ainsi, les octets représentant le texte "This" n'est pas lu à partir du flux d'entrée.

Méthode close()

Pour fermer le flux d'entrée du fichier, nous pouvons utiliser le close() méthode. Une fois le close() est appelée, nous ne pouvons pas utiliser le flux d'entrée pour lire les données.

Dans tous les exemples ci-dessus, nous avons utilisé le close() méthode pour fermer le flux d'entrée du fichier.

Autres méthodes de FileInputStream

Méthodes	Descriptions
`finalize()`	s'assure que le `close()` la méthode est appelée
`getChannel()`	renvoie l'objet de `FileChannel` associé au flux d'entrée
`getFD()`	renvoie le descripteur de fichier associé au flux d'entrée
`mark()`	marquer la position dans le flux d'entrée jusqu'à laquelle les données ont été lues
`reset()`	renvoie le contrôle au point du flux d'entrée où la marque a été définie

Pour en savoir plus, visitez Java FileInputStream (documentation officielle de Java).

Classe Java OutputStream Classe Java FileOutputStream

Java