Comment lire un fichier en Java

Java

La prise de la contribution de l'utilisateur est une partie importante de la création d'un programme, et il peut y avoir plusieurs façons de prendre la contribution pour l'utiliser dans notre programme. L'une de ces méthodes consiste à lire les données d'un fichier. Prendre des entrées à partir du fichier peut être un peu délicat et difficile à saisir, mais c'est avantageux pour stocker une grande quantité de données.

Lire les données d'un fichier

La classe Scanner est utilisée pour prendre des entrées dans un programme Java. Ainsi, nous pouvons utiliser la classe scanner pour lire les données d'un fichier. System.in est passé en tant qu'argument dans l'objet scanner, qui spécifie de prendre l'entrée du clavier à la place de System.in. Nous pouvons passer un objet fichier comme indiqué.

File myFile = new File("Customers.txt");
Scanner inputFile = new Scanner(myFile);

Ainsi, la première instruction crée un objet du fichier, le mot-clé File est utilisé pour définir un fichier, représentant le fichier customers.txt. La deuxième ligne prend une entrée et transmet une référence à l'objet fichier comme entrée. Pour cela, nous devons importer deux bibliothèques.

import java.util.Scanner; // Needed for Scanner class
import java.io.*; //needed for file and IO Exception

Une fois la lecture du fichier terminée, l'instruction suivante ferme le fichier qui est la source de sortie de l'objet :

inputFile.close();

Lire les lignes d'un fichier

La ligne suivante() La méthode Java est utilisée pour lire une ligne d'entrée et renvoie une chaîne en sortie. La ligne suivante() La méthode peut également être utilisée pour lire les entrées des fichiers. Maintenant, pour voir comment cela fonctionne, nous devons d'abord créer un fichier dans le même répertoire que le code. Créez un fichier nommé hello.txt et suivez l'exemple illustré ci-dessous :

 import java.util.Scanner; // Needed for Scanner class
 import java.io.*; // Needed for File and IOException

 /**
 This program reads the first line from a file.
 */
 public class ReadFirstLine
 {
   public static void main(String[] args) throws IOException
   {

   // Open the file.
   File file = new File("Hello.txt");
   Scanner inputFile = new Scanner(file);

   // Read the first line from the file.
   String line = inputFile.nextLine();

   // Display the line.
   System.out.println("The first line in the file is:");
   System.out.println(line);

   // Close the file.
   inputFile.close();
   }
 }

Maintenant, puisque Java est un langage orienté objet, tout le code écrit doit être à l'intérieur d'une classe. Le programme ci-dessus ouvre un fichier nommé Hello.txt, lit la première ligne et affiche la sortie.

Lorsqu'un fichier est ouvert en lecture, une valeur spéciale connue sous le nom de position de lecture est conservée pour un fichier même si nous ne pouvons pas le voir, mais il est là en interne. La position de lecture d'un fichier marque l'emplacement du prochain élément qu'il lira. Lorsqu'un fichier est ouvert, la position de lecture pointe vers le premier élément, et après avoir lu cet élément, puis la position de lecture passe à l'élément suivant.

Que fait-on si on veut lire plusieurs lignes jusqu'à la fin du fichier ? Nous allons simplement parcourir tout le processus de lecture du fichier.

Détection de la fin du fichier

Parfois, nous devons lire le contenu de tout le fichier et ne savons pas combien de lignes nous devons parcourir. Dans cette situation, nous utilisons la boucle while et la méthode hasNext(). La méthode hasNext() est une fonction de la classe scanner qui détermine si le fichier a plus de données à lire ou non. S'il y a plus de données à lire, la méthode hasNext() renvoie true, et lorsque nous atteignons la fin du fichier, elle renvoie false.

 import java.util.Scanner; // Needed for the Scanner class
 import java.io.*; // Needed for the File and IOException

 /**
 This program reads data from a file.
 */

 public class FileRead
 {
   public static void main(String[] args) throws IOException
   {
     // Open the file.
     File file = new File("days.txt");
     Scanner inFile = new Scanner(file);

     // Read lines from the file until no more are left.
     while (inFile.hasNext())
     {
     // Read the next day.
     String days = inFile.nextLine();

     // Display the last day read.
     System.out.println(days);
     }

     // Close the file.
     inFile.close();
     }
   }

Lecture d'un fichier binaire

Un fichier binaire n'est pas comme un fichier texte car il ne contient pas de données sous forme de texte. Par conséquent, nous ne pouvons pas afficher le contenu d'un fichier binaire. Un fichier binaire est beaucoup plus efficace qu'un fichier texte car il y a une conversion minimale lors de sa lecture.

Pour gérer les fichiers binaires, nous avons la classe suivante :

FileInputStream :cette classe vous permet d'ouvrir un fichier binaire et d'établir une connexion avec lui. Mais, il ne fournit que des fonctionnalités de base comme la lecture d'octets.
DataInputStream :cette classe est utilisée avec FileInputStream et vous permet de lire des données de type primitif et des objets chaîne à partir du fichier binaire.

Maintenant, nous ouvrons un fichier binaire pour lire l'entrée. Nous prenons l'entrée d'un fichier .dat comme indiqué ci-dessous dans l'extrait de code.

FileInputStream fstream = new FileInputStream("Info.dat");
DataInputStream inputFile = new DataInputStream(fstream);

Ici, nous avons ouvert un fichier info.dat. Lorsque l'objet DataInputStream a été créé, nous pouvons l'utiliser pour lire les données du fichier binaire. Le code ci-dessous montre comment nous pouvons lire un fichier binaire puis en afficher les nombres.

import java.io.*;

 /**
 This program opens a binary file, reads
 and displays the contents.
 */

 public class ReadBinaryFile
 {
 public static void main(String[] args) throws IOException
 {
 int number; // A number read from the file
 boolean endOfFile = false; // EOF flag

 // Create the binary file input objects.
 FileInputStream fstream =
 new FileInputStream("Integers.dat");
 DataInputStream inFile =
 new DataInputStream(fstream);

 System.out.println("Reading numbers from the file:");

   // Read the contents of the file.
   // read until End of File is reached
   while (!endOfFile)
   {
   try
   {
   number = inFile.readInt();
   System.out.print(number + " ");
   }
   catch (EOFException e)
   {
   endOfFile = true;
   }
   }

   System.out.println("\nDone.");

   // Close the file.

     inFile.close();
 }
 }

Le code ci-dessus est lié au code ci-dessous. Le fichier est d'abord ouvert pour l'écriture dans le code ci-dessous, et un tableau de nombres est écrit dans le fichier, comme indiqué ci-dessous. Ce fichier .dat est utilisé dans le code ci-dessus pour lire les données d'un fichier binaire. La sortie du code ci-dessus sera le tableau de nombres indiqué dans le code ci-dessous.

import java.io.*;

 /**
 This program opens a binary file and writes the contents
 of an int array to the file.
 */

 public class WriteBinaryFile
 {
   public static void main(String[] args)
   throws IOException
   {
   // An array to write to the file
   int[] numbers = { 1, 3, 5, 7, 9, 11, 13 };

   // Create the binary output objects.
   FileOutputStream fstream =
   new FileOutputStream("Integers.dat");
   DataOutputStream outFile =
   new DataOutputStream(fstream);

   System.out.println("Writing the numbers to the file...");

   // Write the array elements to the file.
   for (int i = 0; i < numbers.length; i++)
   outFile.writeInt(numbers[i]);

   System.out.println("Done.");

   // Close the file.
   outFile.close();
   }
 }

Conclusion

Ainsi, la question qui se pose est la suivante :"Pourquoi lire l'entrée d'un fichier alors que nous pouvons simplement la lire à partir du clavier ?". La réponse à cette question est que le traitement des fichiers est efficace et flexible. De plus, l'archivage permet de stocker et d'afficher une grande quantité de données, ce qui ne serait pas possible sur une console.