Die Klassen File, Path, Files: Überblick, Erstellung von Objekten

1. Klasse File: wie alles begann

Auch wenn wir bereits festgestellt haben, dass die Klasse File in neuen Projekten besser nicht verwendet wird, gibt es dennoch viele Legacy‑Systeme, in denen sie eingesetzt wird. Daher ist es wichtig, sie zu verstehen und damit arbeiten zu können. Die Klasse File ist eine alte Art, eine Datei oder ein Verzeichnis auf dem Datenträger zu repräsentieren. Verwechseln Sie es jedoch nicht: Ein Objekt File ist nicht die Datei selbst, sondern nur ein „Zeiger“/„Ausweis“ des Pfads. Zum Beispiel erzeugt der Ausdruck File f = new File("hello.txt"); keine Datei auf dem Datenträger – Sie haben lediglich einen Pfad beschrieben.

Wie erstellt man ein Objekt File?

import java.io.File;

public class FileDemo {
    public static void main(String[] args) {
        File file = new File("example.txt"); // relativer Pfad
        File folder = new File("mydir");     // Verzeichnis

        System.out.println("Absoluter Pfad: " + file.getAbsolutePath());
        System.out.println("Existiert die Datei? " + file.exists());
        System.out.println("Ist das eine Datei? " + file.isFile());
        System.out.println("Ist das ein Verzeichnis? " + folder.isDirectory());
    }
}

Wichtig zu beachten:
Das Erzeugen eines File-Objekts erstellt keine Datei auf dem Datenträger. Es ist nur ein „Platzhalter“. Damit die Datei tatsächlich entsteht, müssen Sie die Erstellung explizit anstoßen (z. B. Daten schreiben oder file.createNewFile() aufrufen).

Wichtige Methoden der Klasse File

• exists() – prüft, ob Datei/Verzeichnis existiert.
• isFile() – ist es eine Datei (und kein Ordner)?
• isDirectory() – ist es ein Verzeichnis?
• getAbsolutePath() – absoluten Pfad erhalten.
• length() – Dateigröße in Byte.
• getName() – Name der Datei oder des Ordners.
• delete() – Datei/Verzeichnis löschen (wenn leer).

Beispiel: Informationen über die Datei ausgeben

File file = new File("example.txt");
System.out.println("Name: " + file.getName());
System.out.println("Pfad: " + file.getAbsolutePath());
System.out.println("Größe: " + file.length() + " Byte");
System.out.println("Existiert? " + file.exists());

2. Klasse Path: der moderne Blick auf Dateien

Path ist Teil der neuen File‑API (NIO.2, ab Java 7). Es ist die Abstraktion eines Pfads zu einer Datei/einem Verzeichnis; der Pfad kann sich nicht nur auf einem lokalen Laufwerk befinden, sondern zum Beispiel auch in einem ZIP‑Archiv oder auf einer Remote‑Ressource (bei vorhandenem Provider).

Wenn File eine alte Papierkarte ist, ist Path ein GPS‑Navigator.

Wie erstellt man ein Objekt Path?

import java.nio.file.Path;
import java.nio.file.Paths;

public class PathDemo {
    public static void main(String[] args) {
        Path path1 = Paths.get("example.txt"); // relativer Pfad
        Path path2 = Paths.get("folder", "file.txt"); // Pfadteile zusammenfügen

        System.out.println("Pfad 1: " + path1.toAbsolutePath());
        System.out.println("Pfad 2: " + path2.toAbsolutePath());
    }
}

Plus: Sie müssen sich nicht um Trenner kümmern. Paths.get wählt das korrekte Format für Ihr Betriebssystem.

Konvertierung zwischen File und Path

• File → Path: file.toPath()
• Path → File: path.toFile()

File file = new File("test.txt");
Path path = file.toPath();

Path anotherPath = Paths.get("data.txt");
File anotherFile = anotherPath.toFile();

Arbeiten mit Pfaden: resolve, relativize, normalize

Pfadteile verbinden (resolve)

Path dir = Paths.get("myfolder");
Path file = dir.resolve("notes.txt"); // myfolder/notes.txt
System.out.println(file); // myfolder/notes.txt

Relativer Pfad (relativize)

Path pathA = Paths.get("folderA/file1.txt");
Path pathB = Paths.get("folderA/subfolder/file2.txt");
Path relative = pathA.relativize(pathB);
System.out.println(relative); // ../subfolder/file2.txt

Pfad normalisieren (normalize)

Path messy = Paths.get("folder/../folder/file.txt");
Path clean = messy.normalize();
System.out.println(clean); // folder/file.txt

Beispiel: Pfad zu einer Datei aufbauen

Path home = Paths.get(System.getProperty("user.home"));
Path docs = home.resolve("Documents");
Path myFile = docs.resolve("myfile.txt");
System.out.println("Pfad zur Datei: " + myFile.toAbsolutePath());

3. Klasse Files: Ihr Schweizer Taschenmesser

Die Klasse Files aus dem Paket java.nio.file ist ein Utility‑Satz statischer Methoden für Datei‑ und Verzeichnisoperationen auf Basis von Path. Sie kann so gut wie alles: Existenz prüfen, erstellen/löschen, lesen/schreiben, kopieren/verschieben, Attribute abrufen und den Verzeichnisbaum durchlaufen.

Wichtige Methoden der Klasse Files

• Files.exists(path) – prüft, ob Datei/Verzeichnis existiert.
• Files.isDirectory(path) – ist es ein Verzeichnis?
• Files.size(path) – Dateigröße.
• Files.createFile(path) – Datei erstellen.
• Files.createDirectory(path) – Verzeichnis erstellen.
• Files.delete(path) – Datei/Verzeichnis löschen.
• Files.copy(src, dest) – Datei kopieren.
• Files.move(src, dest) – verschieben/umbenennen.
• Files.getLastModifiedTime(path) – Zeitpunkt der letzten Änderung.
• Files.readAllBytes(path) – gesamte Datei in ein Byte‑Array lesen.
• Files.readAllLines(path) – alle Zeilen einer Textdatei lesen.
• Files.write(path, bytes) – Bytes in eine Datei schreiben.

Beispiel: Datei prüfen

import java.nio.file.*;

public class FilesDemo {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");

        System.out.println("Existiert die Datei? " + Files.exists(path));
        System.out.println("Ist das ein Verzeichnis? " + Files.isDirectory(path));

        if (Files.exists(path)) {
            try {
                System.out.println("Dateigröße: " + Files.size(path) + " Byte");
            } catch (Exception e) {
                System.out.println("Fehler beim Ermitteln der Größe: " + e.getMessage());
            }
        }
    }
}

4. Praxis: Objekte erstellen, Eigenschaften ausgeben

Objekte für Datei und Verzeichnis erstellen

import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;

public class CompareDemo {
    public static void main(String[] args) {
        // Alter Ansatz
        File oldFile = new File("test.txt");
        File oldDir = new File("mydir");

        // Neuer Ansatz
        Path newFile = Paths.get("test.txt");
        Path newDir = Paths.get("mydir");

        System.out.println("=== File API ===");
        System.out.println("Datei: " + oldFile.getAbsolutePath());
        System.out.println("Existiert? " + oldFile.exists());
        System.out.println("Ist das eine Datei? " + oldFile.isFile());
        System.out.println("Ist das ein Verzeichnis? " + oldDir.isDirectory());

        System.out.println("\n=== Path API ===");
        System.out.println("Datei: " + newFile.toAbsolutePath());
        System.out.println("Existiert? " + java.nio.file.Files.exists(newFile));
        System.out.println("Ist das eine Datei? " + java.nio.file.Files.isRegularFile(newFile));
        System.out.println("Ist das ein Verzeichnis? " + java.nio.file.Files.isDirectory(newDir));
    }
}

Dateieigenschaften ausgeben

import java.nio.file.*;

public class FileProperties {
    public static void main(String[] args) {
        Path path = Paths.get("test.txt");

        System.out.println("Absoluter Pfad: " + path.toAbsolutePath());
        System.out.println("Dateiname: " + path.getFileName());
        System.out.println("Übergeordnetes Verzeichnis: " + path.getParent());

        if (Files.exists(path)) {
            try {
                System.out.println("Größe: " + Files.size(path) + " Byte");
                System.out.println("Letzte Änderung: " + Files.getLastModifiedTime(path));
            } catch (Exception e) {
                System.out.println("Fehler beim Abrufen der Informationen: " + e.getMessage());
            }
        } else {
            System.out.println("Datei nicht gefunden.");
        }
    }
}

5. Vergleich: File vs Path/Files

Kurz: Wann was verwenden?

• Für neue Projekte – verwenden Sie Path und Files.
• Für die Wartung alten Codes – manchmal müssen Sie mit File arbeiten.

6. Nützliche Hinweise

Relative und absolute Pfade

Ein relativer Pfad ist relativ zum aktuellen Arbeitsverzeichnis; ein absoluter ist der vollständige Pfad vom Wurzelverzeichnis des Dateisystems.

Path relative = Paths.get("data", "file.txt");
Path absolute = relative.toAbsolutePath();
System.out.println("Absoluter Pfad: " + absolute);

Plattformübergreifend

Path und Files berücksichtigen die Besonderheiten des Betriebssystems (Trennzeichen, Encodings usw.). Schreiben Sie keine Pfade manuell der Form "C:\\folder\\file.txt" – verwenden Sie Paths.get und resolve.

Konvertierung zwischen File und Path

Wenn Sie alten Code auf File haben, können Sie leicht auf die neue API umsteigen:

File legacy = new File("legacy.txt");
Path modern = legacy.toPath();
if (Files.exists(modern)) {
    // Jetzt können Sie den gesamten Funktionsumfang von NIO.2 nutzen
}

Dateiexistenz prüfen

Path path = Paths.get("notes.txt");
if (Files.exists(path)) {
    System.out.println("Datei gefunden!");
} else {
    System.out.println("Datei existiert nicht.");
}

7. Mini‑Praxis: Datei und Verzeichnis erstellen und prüfen

import java.nio.file.*;

public class MiniPractice {
    public static void main(String[] args) throws Exception {
        Path dir = Paths.get("demo_dir");
        Path file = dir.resolve("hello.txt");

        // Verzeichnis erstellen, falls nicht vorhanden
        if (!Files.exists(dir)) {
            Files.createDirectory(dir);
            System.out.println("Verzeichnis erstellt: " + dir.toAbsolutePath());
        }

        // Datei erstellen, falls nicht vorhanden
        if (!Files.exists(file)) {
            Files.createFile(file);
            System.out.println("Datei erstellt: " + file.toAbsolutePath());
        }

        // Eigenschaften ausgeben
        System.out.println("Datei vorhanden? " + Files.exists(file));
        System.out.println("Ist das eine Datei? " + Files.isRegularFile(file));
        System.out.println("Größe: " + Files.size(file) + " Byte");

        // Datei und Verzeichnis löschen (optional)
        Files.delete(file);
        Files.delete(dir);
        System.out.println("Datei und Verzeichnis gelöscht.");
    }
}

8. Typische Fehler beim Arbeiten mit File/Path/Files

Fehler Nr. 1: Verwechslung zwischen File und Path. Viele Einsteiger versuchen, Methoden von Files mit einem Objekt File zu verwenden. Denken Sie daran: Files.* arbeitet mit Path. Wenn Sie ein File haben, rufen Sie zuerst file.toPath() auf.

Fehler Nr. 2: Erwartung, dass das Erzeugen eines File- oder Path-Objekts eine Datei erstellt. Ein Pfadobjekt ist ein Platzhalter, keine echte Datei. Zum Erstellen verwenden Sie Files.createFile(path) oder schreiben Sie Daten.

Fehler Nr. 3: Manuelles Zusammensetzen von Pfaden als String. Schreiben Sie nicht "folder/file.txt" oder "folder\\file.txt". Verwenden Sie Paths.get(...) und resolve(...). Das ist sicherer und plattformübergreifend.

Fehler Nr. 4: Ausnahmen ignorieren. Dateioperationen werfen IOException und andere Ausnahmen. Behandeln Sie sie mit try-catch oder lassen Sie sie weiterreichen (throws).

Fehler Nr. 5: Mit File.exists() prüfen und dann mit Path arbeiten. Halten Sie sich möglichst an einen Stil: Wenn Sie mit Path begonnen haben – verwenden Sie Files.exists(path) und die übrigen Methoden von Files.