Fichier texte en Java

Les programmeurs utilisent des fichiers texte en Java lorsqu'ils travaillent avec des applications Java qui nécessitent la lecture et l'écriture sur un fichier. Les fichiers texte sont des moyens universels de stocker des informations, du code ou toute autre donnée. Un fichier texte est considéré comme une séquence de caractères organisés horizontalement. Les fichiers texte en Java ont des extensions telles que .java contenant des codes Java. Java fournit différents utilitaires vous permettant de gérer des fichiers de texte brut en les lisant ou en y écrivant. Vous pouvez choisir n'importe quel utilitaire de lecture/écriture selon votre compréhension.

Points forts

• Un fichier texte est composé de différents caractères, où l'on peut effectuer des opérations de lecture et d'écriture à l'aide de java.io.package.
• Pour lire, vous pouvez utiliser Reader Class ou Utility Class. Certaines classes d'utilitaires sont les classes File Class, FileReader, BufferedReader et Scanner.
• Pour écrire dans un fichier en Java, vous pouvez utiliser Java 7 Files, FileWriter, BufferedWriter et FileOutputStream.
• En utilisant différentes méthodes, vous pouvez travailler efficacement autour des fichiers texte en Java.

Comment lire des fichiers texte en Java ?

• Dans les fichiers texte, chaque ligne comporte des caractères simples et chaque ligne est marquée par un symbole invisible de « fin de ligne » représentant la fin de cette ligne spécifique.
• Pour lire des fichiers texte en Java, différents utilitaires sont disponibles. Chaque utilitaire a sa façon de lire le fichier texte et offre des fonctionnalités qui diffèrent des autres alternatives.
• Ici, nous expliquerons différentes méthodes avec un bon exemple pour une meilleure compréhension.

Avant de commencer avec les méthodes, nous envisageons un fichier texte « test.txt » au chemin « /Users/praashibansal/Desktop/Data/test.txt » avec le contenu « Bonjour, là ».

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Méthode 1 – Utilisation de la classe BufferedReader

• Vous pouvez utiliser cette méthode pour lire le texte du flux de saisie de caractères. Vous pouvez utiliser la taille de tampon par défaut (8 Ko) ou spécifier la vôtre. Il prend en charge l'encodage.
• Chaque requête possède un lecteur qui crée une requête de lecture à partir du flux de caractères ou du flux d'octets sous-jacent.
• Ainsi, de nombreux développeurs recommandent d'envelopper un BufferedReader autour de n'importe quel lecteur en utilisant ses opérations read().
• Cela fonctionne bien pour traiter des fichiers volumineux. Cette méthode est synchronisée et peut donc être utilisée à partir de plusieurs threads.

Code :

import java.io.*;
 public class BReader {
       public static void main(String[] args) throws Exception
    {
              File f = new File(
            "https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt");
             // Creating an object
        BufferedReader b
            = new BufferedReader(new FileReader(f));
        // Declaring a string variable
        String s;
        // Condition holds till
        // there is a character in a string
        while ((s = b.readLine()) != null)
            // Print the string
            System.out.println(s);
    }
}

Sortie :

Méthode 2 – Utilisation de la classe FileReader

• Vous pouvez utiliser FileReader pour obtenir le BufferedReader et commencer à lire le fichier.
• Contrairement à BufferedReader, il ne prend pas en charge l'encodage et utilise à la place l'encodage par défaut du système.
• C'est juste une façon simple de lire les caractères.
• Cette classe utilise trois constructeurs.
• FileReader(File file) : crée un nouveau FileReader. Le fichier est le fichier à partir duquel vous lirez le contenu.
• FileReader(FileDescriptor fd) : crée un nouveau FileReader qui lit à partir du fichier spécifié comme FileDescriptor.
• FileReader(String fileName) : crée un nouveau FileReader qui lira à partir du fichier nommé fileName.

Code :

import java.io.*;
public class RFile {
     public static void main(String[] args) throws Exception
    {
        // Passing the file’s path 
        FileReader f = new FileReader(
            "https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt");
        // declaring loop variable
        int i;
             while ((i = f.read()) != -1)
            // Print the content of a file
            System.out.print((char)i);
    }
}

Sortie :

Méthode 3 – Utilisation de la classe Scanner

• Il s'agit d'un simple scanner de texte, capable d'analyser les types primitifs et les chaînes via une expression régulière.
• Il divise l'entrée en jetons via un modèle de délimiteur. Par défaut, le délimiteur est l'espace.
• Ensuite, le jeton se convertit en différents types de valeurs.

Code :

import java.io.File;
import java.util.Scanner;
public class ReadScan
{
  public static void main(String[] args) throws Exception
  {
    // passing the file’s path
    File file = new File("https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt");
    Scanner s = new Scanner(file);
    while (s.hasNextLine())
      System.out.println(s.nextLine());
  }
}

Sortie :

Méthode 4 – Utilisation de la méthode de classe Files

• La classe Files UTILISE les méthodes suivantes pour lire le fichier.
• readAllBytes(Path path) : lit tous les octets du fichier et renvoie le tableau d'octets contenant les octets du fichier.
• readAllLines(Path path, Charsetcs) : lit toutes les lignes du fichier et renvoie la liste avec les lignes du fichier.

Code :

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class FCExample {
	public static void main(String[] args) {
		Path path = Paths.get("https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt");
		try {
			byte[] b = Files.readAllBytes(path);
			System.out.println("Read bytes: \n"+new String(b));
		} catch (IOException e) {
		}
	}

}

Sortie :

How to Write a Text File in Java?

• Writing a text file in Java is also a simple process. Java offers different utilities to help write the lines to the file.
• Now for this process, we are assuming a file at the location- C:\\Users\\Data\\Desktop\\write.txt to which we are writing.

Method 1 – Using FileWriter Method

• This all-in-one method allows you to write int, byte array, and String to the File.
• It allows you to write directly into Files and is used in case of the less writes.
• Using the FileWriter method, you can write part of the String or byte array.

Code:

import java.io.FileWriter; 
 public class FWFile { 
 public static void main(String args[]){ 
 try{ 
 FileWriter f=new FileWriter("https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt"); 
 f.write("Hello"); 
 f.close(); 
 }
catch(Exception e)
{
System.out.println(e);
} 
 System.out.println("Hello"); 
 } 
 }

Output:

Method 2 – Using BufferedWriter Method

• BufferedWriter is similar to FileWriter, but BufferedWriter uses an internal buffer to write data into File.
• It works well if you need to do more write operations and to ensure performance.

Code:

import java.io.FileWriter;
import java.io.BufferedWriter;
import java.io.IOException;

public class BRExample {
  public static void main(String args[]) {
    String data = "data for output file";
    try {
      // Creates a FileWriter
      FileWriter file = new FileWriter("https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt");
        try ( // Creates a BufferedWriter
                var o = new BufferedWriter(file)) {
            // Writes the string to the file
            o.write(data);
        }
    }
    catch (IOException e) {
      e.getStackTrace();
    }
  }
}

Output:

Method 3 – Using FileOutputStream Method

• For writing text to the file, you can simply use FileWriter and BufferedWriter.
• But, if you want the raw stream data to be written directly into a file, it is recommended to use the FileOutputStream utility.
• With this method, you must create the class object with the specific filename to write data into a file.
• The following example converts the string content into the byte array we will write into the file using the write() method.

Code:

import java.io.FileOutputStream;
import java.io.IOException;
public class GFG {
       public static void main(String[] args)
    {
        String f = "Hello";
        FileOutputStream o = null;
        // starting Try block 
        try {
            // creating an object of FileOutputStream
            o = new FileOutputStream("https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt");
            // storing byte content from string
            byte[] str = f.getBytes();
            // writing into the file
            o.write(str);
            // printing success message 
            System.out.print(
                "data added successfully.");
        }
        // Catch block for exception handling
        catch (IOException e) {
                     System.out.print(e.getMessage());
        }
        finally {
            // closing the object
            if (o != null) {
                // checking if the file is closed 
                       try {
                                                       o.close();
                }
                catch (IOException e) {
                    // showing exception message
                    System.out.print(e.getMessage());
                }
            }
        }
    }
}

Output:

Method 4 – Using Files Class

• In Java 7, you will get another utility, Files class, allowing you to write to a text file using its write function.
• Internally, this class uses the OutputStream utility to write a byte array into the file.

Code:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
/**
 * Java Files write file example
 * 
 * @author pankaj
 *
 */
public class FCExample {
	public static void main(String[] args) {
		Path path = Paths.get("https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt");
		try {
			String str = "Example";
			byte[] bs = str.getBytes();
			Path w = Files.write(path, bs);
			System.out.println("Written content in file:\n"+ new String(Files.readAllBytes(w)));
		} catch (IOException e) {
		}
	}
}

Output:

Conclusion

Reading and writing a file in Java is a straightforward process. With the availability of different methods and utilities in Java, you can choose a specific way to read from and write to a file. Each utility has its functionality that makes it different from others.

FAQs

Q1. What are the different methods to read a text file in Java?

Answer: To read, you can use Reader Class or utility class. Some utility classes are- File Class, FileReader, BufferedReader, and Scanner class.

Q2. What are the different methods for writing a text file in Java?

Answer: To write a file in Java, you can use FileWriter, BufferedWriter, java 7 Files, FileOutputStream, and many other methods.

Q3. What package to use for handling files in Java?

Answer: You can easily import the File class from the java.io package to work with files.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!