FileSystem und Path

Motivation für Abstraktion

• Java ist plattformunabhängig, der Umgang mit Dateien ist aber extrem plattformabhängig
• Unterschiedliche Separatoren (/ vs. \)
• Unterschiedliche Konzepte für Dateisystem-Wurzeln (/ vs. c:\, d:\)
• Unterschiedliche Berechtigungen (rwx vs. ACLs)
• Die Klassen Path und FileSystem abstrahieren von der Plattform und erlaubt es relativ abstrakt in Java mit Dateien zu operieren

Es gibt neben den neuen Klassen Path und FileSystem noch eine alte Schnittstelle für den Umgang mit Dateien in Form der Klasse java.io.File. Diese ist inzwischen allerdings veraltet und wird nur noch dort verwendet, wo die Schnittstellen der Klassen explizit diese Klasse erwarten. Da man aber mit der Methode toFile() jedes Path-Objekt in ein File-Objekt umwandeln kann, gibt es keinen Grund mehr, die alten Klassen zu verwenden.

FileSystem und FileSystems

Die Klasse FileSystem in java.nio.file stellt eine Abstraktionsschicht über dem Dateisystem dar und ermöglicht es, auf verschiedene Dateisysteme unabhängig von der zugrunde liegenden Implementierung zuzugreifen.

Die Funktionsweise der Klasse FileSystem besteht darin, dass sie eine Schnittstelle bereitstellt, um das Dateisystem zu durchsuchen, Dateien und Verzeichnisse zu erstellen und zu löschen, Metadaten abzurufen und andere Dateisystemoperationen durchzuführen. Die Klasse bietet auch die Möglichkeit, Dateisysteme zu konfigurieren und anzupassen, z. B. indem sie den Zugriff auf bestimmte Verzeichnisse einschränkt oder die Unterstützung für bestimmte Dateiformate aktiviert oder deaktiviert.

Ein Anwendungszweck der Klasse FileSystem ist es, es Entwickler:innen zu ermöglichen, plattformunabhängigen Code zu schreiben, der auf verschiedenen Betriebssystemen und Dateisystemen funktioniert.

FileSystem

• beschreibt ein Dateisystem
• abstrakte Klasse, die für die Dateisysteme implementiert wird
• getPath() liefert Path-Objekt für weitere Arbeit mit Dateisystem

Die Klasse FileSystems stellt Factory-Methoden zur Verfügung, um ein FileSystem-Objekt für ein bestimmtes Dateisystem zu erzeugen. Sie bietet auch eine Möglichkeit, auf spezielle Dateisysteme zuzugreifen, wie z. B. ein ZIP-Dateisystem. Es können FileSystem-Objekte für verschiedene Arten von Dateisystemen erstellt werden, einschließlich solcher, die in Dateien oder Netzwerkressourcen eingebettet sind.

FileSystems

• Factory-Klasse, um konkretes FileSystem-Objekt zu erzeugen
• getDefault() liefert FileSystem für aktuelles System
• getFileSystem(URI uri) liefert FileSystem für die gegebene URI

Ein Dateisystem legt die Organisation und Speicherung von Daten auf einem Speichermedium wie einer Festplatte oder einem USB-Stick fest. Es definiert die Struktur und die Regeln, wie Daten gespeichert, abgerufen und geändert werden können. Das Dateisystem ermöglicht es, auf Dateien und Ordner zuzugreifen und diese zu manipulieren, und stellt sicher, dass Daten effizient und sicher auf dem Speichermedium gespeichert werden.

Path

Die Klasse Path in java.nio.file repräsentiert einen Pfad zu einer Datei oder einem Verzeichnis auf dem Dateisystem. Sie kann verwendet werden, um auf Dateien oder Verzeichnisse zuzugreifen und mit ihnen zu arbeiten, indem sie die erforderlichen Operationen wie Lesen, Schreiben und Löschen von Dateien bereitstellt.

Der Zweck der Klasse Path besteht darin, einen einheitlichen und plattformunabhängigen Weg zum Zugriff auf Dateien und Verzeichnisse bereitzustellen. Sie abstrahiert die Unterschiede in den Dateisystemen und bietet eine konsistente API, die unabhängig vom zugrunde liegenden Dateisystem funktioniert.

Die Klasse Path bietet auch eine Vielzahl von Methoden zur Manipulation von Pfaden, einschließlich der Konkatenation von Pfaden, der Umwandlung von Pfaden in andere Formate und der Ermittlung von Informationen über den Pfad, wie z. B. Dateiname, Verzeichnisname und Dateierweiterung.

Path

• repräsentiert den Pfad zu einer Datei / einem Verzeichnis
• bietet Methoden zum Arbeiten mit Dateien und Verzeichnissen

Beispiel mit Path

FileSystem fs = FileSystems.getDefault();
Path path = fs.getPath("/etc/passwd");
System.out.println(path.getFileName()); // -> passwd
System.out.println(path.getParent()); // -> /etc
System.out.println(path.getRoot()); // -> /

for (Path p : path) {
    System.out.print(p + ", "); // -> etc, passwd,
}

Wichtige Methoden von Path

• static Path of(String first, String... more)
  Kurzfassung für FileSystems.getDefault(),getPath(...)
• static Path of(URI uri)
  Neuer Pfad aus URI
• Path resolve(...)
  Pfad aus Komponenten zusammenbauen
• boolean endsWith(...), boolean startsWith(...)
  Anfang und Ende des Pfades prüfen
• boolean isAbsolute()
  Testet of der Pfad absolut ist

• Path getFileName()
  Letzten Teil des Pfades bestimmen (den Dateinamen)
• Path getParent()
  Alles vor dem letzten Teil bestimmen
• Path getRoot()
  Wurzel des Dateisystems
• FileSystem getFileSystem()
  Referenz auf das dazugehörige Dateisystem

• Path getName(int index)
  Element an der Stelle index
• int getNameCount()
  Anzahl der Elemente
• Path normalize()
  Entfernt unnötige Teile aus dem Pfad
• Path relativize(Path other)
  Liefert einen neuen Pfad relativ zu other
• Path toAbsolutePath()
  Liefert einen absoluten Pfad

• File toFile()
  Konvertierung in File-Objekt
• URI toUri()
  Konvertierung in URI-Objekt

Beispiel für Path

// Pfad bezogen auf das Nutzer Home
Path path = Paths.get(System.getProperty("user.home"))
                 .resolve("Pictures")
                 .resolve("Urlaub2022");
System.out.println(path); // -> /home/thomas/Pictures/Urlaub2022

// Neuen, absoluten Pfad erzeugen
Path dwnl = path.getParent().resolve("..").resolve("Downloads");
System.out.println(dwnl); // -> /home/thomas/Pictures/../Downloads
System.out.println(dwnl.normalize()); // -> /home/thomas/Downloads
System.out.println(dwnl.isAbsolute()); // -> true

// Relativen Pfad erzeugen
Path videos = dwnl.relativize(Path.of("/home/thomas/Videos"));
System.out.println(videos); // -> ../Videos
System.out.println(videos.isAbsolute()); // -> false

Files

Die Klassen für die Verarbeitung von Ein- und Ausgabe in Form von Streams (InputStream, OutputStream, Reader, Writer) sind objektorientiert elegant entworfen. Für viele Anwendungszwecke, z. B. um Daten komplett aus einer Textdatei zu lesen und dann zu verarbeiten, sind sie allerdings zu komplex und aufwändig zu benutzen. Aus diesem Grund bietet seit Java 1.7 die Klasse Files einen einfacheren Zugang zu den meisten Operationen mit Dateien. Sie stellt eine Sammlung von statischen Hilfs-Methoden zur Verfügung.

• Datei-Operationen: Die Klasse bietet eine Reihe von Methoden zum Kopieren, Verschieben, Umbenennen und Löschen von Dateien und Verzeichnissen.
• Lesen und Schreiben von Dateien: Mit den Methoden der Klasse können Dateien gelesen und geschrieben werden, einschließlich der Möglichkeit, Zeilen aus einer Datei zu lesen und in eine Liste von Strings zu konvertieren.
• Verwaltung von Metadaten: Die Klasse kann auch verwendet werden, um Metadaten von Dateien und Verzeichnissen abzurufen und zu ändern, wie z. B. die Dateigröße, den letzten Zugriffszeitpunkt und die Berechtigungen.

java.nio.file.Files bietet einen Sammlung von Hilfsmethoden zum

• Lesen und Schreiben von Dateien
  readAllBytes, readAllLines, readString, write, writeString
• Kopieren von Daten
  copy
• Erzeugen von Dateisystemobjekten
  createDirectory, createFile, createLink, createSymbolicLink, createTempDirectory, createTempFile
• Verändern von Dateisystemobjekten
  setLastModifiedTime, setOwner, setPosixFilePermissions

• Testen und Lesen von Eigenschaften
  isDirectory, isHidden, isExecutable, isReadable, isWritable, isRegularFile, size
• Vergleichen von Dateien
  mismatch
• Verschieben von Dateien
  move
• Erzeugen von Streams
  newInputStream, newOutputStream
• …