Fermer un fichier en Java

1. Fermer un fichier en utilisant le bloc try-with-resources en Java (7+)
2. Utiliser la méthode close() pour fermer un fichier en Java
3. Conclusion

La gestion des fichiers est une tâche fondamentale en programmation Java et une gestion adéquate des ressources est essentielle. Dans le passé, la fermeture des fichiers nécessitait une intervention manuelle à l’aide de blocs finally ou de la méthode close(), ce qui pouvait être sujet à des erreurs et entraîner des fuites de ressources.

Cependant, avec l’introduction du bloc try-with-resources en Java 7 et l’utilisation continue de la méthode close(), la gestion des fichiers est devenue plus efficace et moins sujette aux erreurs.

Dans cet article, nous explorerons comment fermer efficacement les fichiers en Java en utilisant à la fois le bloc try-with-resources et la méthode close(). Nous aborderons la syntaxe, fournirons des exemples pratiques pour chaque méthode et mettrons en évidence l’importance de la gestion des ressources lors de la manipulation de fichiers.

Fermer un fichier en utilisant le bloc try-with-resources en Java (7+)

Avant Java 7, les développeurs devaient fermer manuellement les fichiers en utilisant des blocs finally, ce qui pouvait entraîner des erreurs et des fuites de ressources. Cependant, avec l’introduction du bloc try-with-resources en Java 7, la gestion des fichiers est devenue plus efficace et moins sujette aux erreurs.

try-with-resources est une fonctionnalité du langage introduite en Java 7 qui simplifie la gestion des ressources. Il gère automatiquement la fermeture des ressources, telles que les fichiers, à la fin du bloc try, que le bloc soit quitté normalement ou en raison d’une exception. La syntaxe pour utiliser try-with-resources avec des fichiers est simple :

try (ResourceType resource = new ResourceType()) {
  // Use the resource here
} catch (Exception e) {
  // Handle exceptions if necessary
}
// Resource is automatically closed when exiting this block

Voici comment utiliser try-with-resources pour fermer des fichiers :

1. Initialisation de la ressource : Dans les parenthèses suivant le mot-clé try, vous déclarez et initialisez la ressource (dans ce cas, une classe liée aux fichiers, telle que FileInputStream, FileOutputStream, BufferedReader ou BufferedWriter). La ressource doit implémenter l’interface AutoCloseable ou ses sous-interfaces, telles que Closeable.
2. Utilisation de la ressource : À l’intérieur du bloc try, vous utilisez la ressource selon vos besoins pour la lecture, l’écriture ou d’autres opérations. Vous n’avez pas besoin de fermer explicitement la ressource dans votre code.
3. Fermeture de la ressource : Une fois que l’exécution quitte le bloc try, que ce soit en raison d’une exécution normale ou d’une exception, la ressource est automatiquement fermée. Vous n’avez pas besoin d’écrire de bloc finally pour assurer la fermeture.

Exemple pratique

Voyons comment try-with-resources fonctionne avec un exemple pratique de lecture de données à partir d’un fichier :

import java.io.FileInputStream;
import java.io.IOException;

public class FileReadExample {
  public static void main(String[] args) {
    try (FileInputStream fis = new FileInputStream("example.txt")) {
      int data;
      while ((data = fis.read()) != -1) {
        System.out.print((char) data);
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
    // The FileInputStream is automatically closed
  }
}

Dans cet exemple, nous ouvrons un fichier en utilisant FileInputStream dans le bloc try et nous lisons son contenu. Une fois que le bloc est quitté, que ce soit en raison d’une exécution normale ou d’une exception, le FileInputStream est automatiquement fermé, libérant ainsi les ressources système.

Gestion des exceptions

try-with-resources simplifie également la gestion des exceptions. Si une exception se produit dans le bloc try, la ressource est automatiquement fermée avant que l’exception ne soit propagée dans la pile d’appels. Vous pouvez capturer et gérer les exceptions dans le bloc catch si nécessaire.

import java.io.FileOutputStream;
import java.io.IOException;

public class FileWriteExample {
  public static void main(String[] args) {
    try (FileOutputStream fos = new FileOutputStream("output.txt")) {
      // Write data to the file
      fos.write("Hello, World!".getBytes());
    } catch (IOException e) {
      e.printStackTrace();
    }
    // The FileOutputStream is automatically closed
  }
}

Utiliser la méthode close() pour fermer un fichier en Java

La classe BufferedWriter est utilisée dans le programme suivant. Cette classe vous permet d’écrire efficacement des tableaux, des chaînes de caractères et des caractères dans un flux de sortie de caractères.

Nous utilisons également la classe FileWriter, conçue pour l’écriture de flux de caractères, ainsi que la classe BufferedWriter.

Un chemin de fichier est représenté par une instance de la classe File. Un chemin d’accès abstrait est construit à partir de la chaîne de chemin d’accès spécifiée.

La méthode write() de BufferedWriter enregistre un certain texte dans le fichier. La méthode newLine() ajoute “/n” en tant que séparateur de ligne.

La plupart des flux n’ont pas besoin d’être fermés après utilisation. Lorsque la source est un canal d’entrée/sortie, il est recommandé de fermer le flux.

Nous devrions invoquer la méthode close() avant de terminer le programme ou d’exécuter des opérations de fichier. Nous pourrions perdre des données si nous ne le faisons pas.

En conséquence, pour fermer le flux et sécuriser les données, la méthode close() est utilisée.

Les flux incluent une méthode appelée BaseStream.close(), qui implémente Autoclosable. Presque toutes les instances de flux n’ont pas besoin d’être fermées car elles sont prises en charge par des collections, qui sont des tableaux qui ne nécessitent aucune gestion de ressources supplémentaire.

Le flux doit être fermé si la source est un canal d’entrée/sortie.

Le contenu du fichier est indiqué ci-dessous avant d’effectuer l’opération d’écriture.

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;

public class CloseFile {
  public static void main(String[] args) throws Exception {
    File file = new File("/Users/John/Temp/demo1.txt");
    if (file.exists()) {
      BufferedWriter bufferWriter = new BufferedWriter(new FileWriter(file, true));
      bufferWriter.write("New Text");
      bufferWriter.newLine();
      bufferWriter.close();
    }
  }
}

Après avoir effectué l’opération d’écriture, le contenu du fichier a changé.

Conclusion

Dans cet article, nous avons démontré comment utiliser à la fois try-with-resources et la méthode close() pour fermer des fichiers, à la fois pour les opérations de lecture et d’écriture, et comment chaque approche simplifie la gestion des exceptions.

Ces méthodes sont considérées comme les meilleures pratiques en programmation Java moderne pour la fermeture de fichiers et d’autres ressources, garantissant une gestion efficace et fiable des ressources.