Schließen Sie eine Datei in Java

1. Schließen einer Datei mit try-with-resources in Java (7+)
2. Verwendung der close()-Methode zum Schließen einer Datei in Java
3. Fazit

Die Bearbeitung von Dateien ist eine grundlegende Aufgabe in der Java-Programmierung, und eine ordnungsgemäße Ressourcenverwaltung ist unerlässlich. Früher erforderte das Schließen von Dateien manuelle Eingriffe mit finally-Blöcken oder der close()-Methode, was fehleranfällig sein und zu Ressourcenlecks führen konnte.

Mit der Einführung von try-with-resources in Java 7 und der fortgesetzten Verwendung der close()-Methode ist die Verwaltung von Dateien jedoch effizienter und weniger fehleranfällig geworden.

In diesem Artikel werden wir untersuchen, wie man Dateien in Java effektiv schließt, sowohl mit try-with-resources als auch mit der close()-Methode. Wir werden die Syntax erläutern, praktische Beispiele für jede Methode geben und die Bedeutung der Ressourcenverwaltung bei der Arbeit mit Dateien hervorheben.

Schließen einer Datei mit try-with-resources in Java (7+)

Vor Java 7 mussten Entwickler Dateien manuell mit finally-Blöcken schließen, was fehleranfällig sein und zu Ressourcenlecks führen konnte. Mit der Einführung von try-with-resources in Java 7 wurde die Behandlung von Dateien effizienter und weniger fehleranfällig.

try-with-resources ist ein Sprachmerkmal, das in Java 7 eingeführt wurde und die Ressourcenverwaltung vereinfacht. Es verwaltet automatisch das Schließen von Ressourcen wie Dateien am Ende des try-Blocks, egal ob der Block normal oder aufgrund einer Ausnahme verlassen wird. Die Syntax für die Verwendung von try-with-resources mit Dateien ist unkompliziert:

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

So verwendet man try-with-resources, um Dateien zu schließen:

1. Initialisierung der Ressource: In den Klammern nach dem try-Schlüsselwort deklarieren und initialisieren Sie die Ressource (in diesem Fall eine klassenbezogene Klasse wie FileInputStream, FileOutputStream, BufferedReader oder BufferedWriter). Die Ressource sollte das AutoCloseable-Interface oder seine Unterinterfaces wie Closeable implementieren.
2. Verwendung der Ressource: Im Inneren des try-Blocks verwenden Sie die Ressource nach Bedarf zum Lesen, Schreiben oder für andere Operationen. Sie müssen die Ressource nicht explizit in Ihrem Code schließen.
3. Schließen der Ressource: Sobald die Ausführung den try-Block verlässt, unabhängig davon, ob dies aufgrund einer normalen Beendigung oder einer Ausnahme geschieht, wird die Ressource automatisch geschlossen. Sie müssen keinen finally-Block schreiben, um den Abschluss sicherzustellen.

Praktisches Beispiel

Schauen wir uns anhand eines praktischen Beispiels das Funktionieren von try-with-resources beim Lesen von Daten aus einer Datei an:

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
  }
}

In diesem Beispiel öffnen wir eine Datei mit FileInputStream innerhalb des try-Blocks und lesen ihren Inhalt aus. Sobald der Block verlassen wird, entweder aufgrund einer normalen Beendigung oder einer Ausnahme, wird der FileInputStream automatisch geschlossen und gibt die Systemressourcen frei.

Ausnahmebehandlung

try-with-resources vereinfacht auch die Ausnahmebehandlung. Wenn im try-Block eine Ausnahme auftritt, wird die Ressource automatisch geschlossen, bevor die Ausnahme im Aufrufstapel weitergeleitet wird. Sie können Ausnahmen im catch-Block abfangen und behandeln, wie es erforderlich ist.

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
  }
}

Verwendung der close()-Methode zum Schließen einer Datei in Java

Die Klasse BufferedWriter wird im folgenden Programm verwendet. Diese Klasse ermöglicht das effiziente Schreiben von Arrays, Zeichenketten und Zeichen in einen Zeichen-Ausgabestrom.

Außerdem verwenden wir die Klasse FileWriter, die für das Schreiben von Zeichenfolgen von Zeichenströmen konzipiert ist, und die Klasse BufferedWriter.

Ein Dateipfad wird durch eine Instanz der Klasse File dargestellt. Ein abstrakter Pfadname wird aus dem angegebenen Pfadnamenstring konstruiert.

Die write()-Methode von BufferedWriter speichert einen Text in der Datei. Die newLine()-Methode fügt einen /n als Zeilentrenner hinzu.

Die meisten Streams müssen nach der Verwendung nicht geschlossen werden. Wenn die Quelle ein Ein-/Ausgabekanal ist, wird empfohlen, den Stream zu schließen.

Wir sollten die Methode close() aufrufen, bevor wir das Programm beenden oder jegliche Dateioperationen ausführen. Andernfalls könnten wir Daten verlieren.

Um den Stream zu schließen und die Daten sicher zu halten, wird die Methode close() verwendet.

Streams enthalten eine Methode namens BaseStream.close(), welche Autoclosable implementiert. Die meisten Stream-Instanzen müssen nicht geschlossen werden, da sie von Sammlungen unterstützt werden, die Arrays sind und keine zusätzliche Ressourcenverwaltung benötigen.

Der Stream sollte geschlossen werden, wenn die Quelle ein IO-Kanal ist.

Der Inhalt der Datei wird unten vor der Schreiboperation gezeigt.

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();
    }
  }
}

Nach der Schreiboperation hat sich der Inhalt der Datei geändert.

Fazit

In diesem Artikel haben wir gezeigt, wie man sowohl try-with-resources als auch die close()-Methode verwendet, um Dateien zu schließen, sowohl für Lese- als auch für Schreiboperationen, und wie jeder Ansatz das Exception Handling vereinfacht.

Diese Methoden gelten als bewährte Praktiken in der modernen Java-Programmierung, um Dateien und andere Ressourcen zu schließen und eine effiziente und zuverlässige Ressourcenverwaltung sicherzustellen.