{"id":8554,"date":"2020-01-15T09:00:00","date_gmt":"2020-01-15T08:00:00","guid":{"rendered":"https:\/\/www.happycoders.eu\/?p=8554"},"modified":"2024-11-29T12:33:00","modified_gmt":"2024-11-29T11:33:00","slug":"dateinamen-verzeichnisnamen-file-path-paths","status":"publish","type":"post","link":"https:\/\/www.happycoders.eu\/de\/java\/dateinamen-verzeichnisnamen-file-path-paths\/","title":{"rendered":"Datei- und Verzeichnisnamen in Java: File, Path, Paths"},"content":{"rendered":"\n<p>Nach dem <a href=\"\/de\/java\/dateien-einfach-schnell-lesen\/\">Lesen<\/a> und <a href=\"\/de\/java\/dateien-schnell-einfach-schreiben\/\">Schreiben<\/a> von Dateien in Java geht es in diesem dritten Teil der Artikelserie darum, wie man die Klassen <code>File<\/code>, <code>Path<\/code> und <code>Paths<\/code> verwendet, um Datei- und Verzeichnispfade zu konstruieren \u2013 und zwar betriebssystemunabh\u00e4ngig. <\/p>\n\n\n\n<p>Wenn du bereits mit Dateioperationen in Java zu tun hattest, hast du diese Klassen wahrscheinlich schon verwendet, um mit <code>new File()<\/code>, <code>Paths.get()<\/code> oder <code>Path.of()<\/code> einen Dateinamen an eine der Schreib- oder Lesemethoden zu \u00fcbergeben. <\/p>\n\n\n\n<p>Viel tiefer steigen die meisten Programmierer in diese Klassen nicht ein. Dies liegt unter anderem daran, dass diese Klassen auch f\u00fcr erfahrene Java-Programmierer verwirrend sein k\u00f6nnen: Was ist der Unterschied zwischen <code>File.getName()<\/code> und <code>File.getPath()<\/code>? Worin unterscheiden sich <code>File.getAbsolutePath()<\/code>, <code>File.getCanonicalPath()<\/code> und <code>Path.normalize()<\/code>? Was ist der Unterschied zwischen <code>Paths.get()<\/code> und <code>Path.of()<\/code>?<\/p>\n\n\n\n<p>Folgende Fragen werden in diesem Artikel beantwortet:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Was ist der Unterschied zwischen Dateiname, Verzeichnisname und Pfad?<\/li>\n\n\n\n<li>Wie konstruiert man einen <em>relativen<\/em> Verzeichnis- bzw. Dateipfad unabh\u00e4ngig vom Betriebssystem?<\/li>\n\n\n\n<li>Wie konstruiert man einen <em>absoluten<\/em> Verzeichnis- bzw. Dateipfad unabh\u00e4ngig vom Betriebssystem?<\/li>\n\n\n\n<li>Was \u00e4nderte sich mit der Einf\u00fchrung der NIO.2 File API?<\/li>\n\n\n\n<li>Was genau liefern die <code>File<\/code>-Methoden <code>getName()<\/code>, <code>getPath()<\/code>, <code>getParent()<\/code>, <code>getParentFile()<\/code>, <code>getAbsolutePath()<\/code>, <code>getAbsoluteFile()<\/code>, <code>getCanonicalPath()<\/code>, <code>getCanonicalFile()<\/code> zur\u00fcck?<\/li>\n\n\n\n<li>Was liefern die <code>Path<\/code>-Methoden <code>getFileName()<\/code>, <code>getName(int index)<\/code>, <code>getParent()<\/code>, <code>getRoot()<\/code>, <code>toAbsolutePath()<\/code> und <code>normalize()<\/code>?<\/li>\n\n\n\n<li>Wie werden mit <code>Path.resolve()<\/code> und <code>Path.resolveSibling()<\/code> <code>Path<\/code>-Objekte verkn\u00fcpft?<\/li>\n\n\n\n<li>Wann verwendet man den nun <code>File<\/code> und wann <code>Path<\/code>? Und kann ich die beiden ineinander konvertieren?<\/li>\n<\/ul>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"grundlagen-begriffsdefinitionen-betriebssystemunabhaengigkeit-nio-2\">Grundlagen: Begriffsdefinitionen, Betriebssystemunabh\u00e4ngigkeit, NIO.2<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"wie-unterscheiden-sich-dateiname-verzeichnisname-relativer-pfad-und-absoluter-pfad\">Wie unterscheiden sich Dateiname, Verzeichnisname, relativer Pfad und absoluter Pfad?<\/h3>\n\n\n\n<p>Bevor wir beginnen m\u00fcssen wir uns \u00fcber die Terminologie einig werden. Oft werden beispielsweise die Bezeichnungen \"Pfad\" und \"Verzeichnis\" durcheinandergebracht.<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Dateiname<\/strong>: der Name einer Datei ohne Verzeichnisangabe und Trennzeichen, z. B. <code>readme.txt<\/code><\/li>\n\n\n\n<li><strong>Verzeichnisname<\/strong>: der Name eines einzelnen Verzeichnisses ohne Elternverzeichnis(se), z. B. <code>apache-maven-3.6.3<\/code> oder <code>log<\/code><\/li>\n\n\n\n<li><strong>Pfad<\/strong>: der \"Weg\" zu einem Objekt des Dateisystems, also zu Dateien und Verzeichnissen. Dieser kann absolut oder relativ sein:\n<ul class=\"wp-block-list\">\n<li>Ein <strong>absoluter Pfad<\/strong> ist immer eindeutig und unabh\u00e4ngig von der aktuellen Position im Dateisystem. <\/li>\n\n\n\n<li>Ein <strong>relativer Pfad<\/strong> bezieht sich auf die aktuelle Position innerhalb des Dateisystems. Er beschreibt, wie man von dieser zum Ziel kommt. Liegt das Ziel im aktuellen Verzeichnis, dann entspricht der relative Pfad f\u00fcr gew\u00f6hnlich dem Datei- bzw. Verzeichnisnamen.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n<p>Die folgende Tabelle zeigt einige Beispiele f\u00fcr absolute und relative Pfade zu Verzeichnissen und Dateien \u2013 sowohl f\u00fcr Windows als auch f\u00fcr Linux\/Mac:<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-stripes\"><table><thead><tr><th><\/th><th>Linux \/ Mac<\/th><th>Windows<\/th><\/tr><\/thead><tbody><tr><td>Absoluter Pfad zu einem Verzeichnis:<\/td><td><code>\/var\/log<\/code><\/td><td><code>C:\\Windows<\/code><\/td><\/tr><tr><td>Absoluter Pfad zu einer Datei:<\/td><td><code>\/var\/log\/syslog<\/code><\/td><td><code>C:\\Windows\\explorer.exe<\/code><\/td><\/tr><tr><td>Relativer Pfad zu einem Verzeichnis:<\/td><td><code>..\/..\/var\/log<\/code><br><br>(von <code>\/home\/user<\/code> zu <code>\/var\/log)<\/code><\/td><td><code>..\\Windows<\/code><br><br>(von <code>C:\\Users<\/code> zu <code>C:\\Windows<\/code>)<\/td><\/tr><tr><td>Relativer Pfad zu einer Datei:<\/td><td><code>..\/..\/var\/log\/syslog<\/code><br><br>(von <code>\/home\/user<\/code> zu <code>\/var\/log\/syslog<\/code>)<\/td><td><code>..\\Windows\\explorer.exe<\/code><br><br>(von <code>C:\\Users<\/code> zu <code>C:\\Windows\\explorer.exe<\/code>)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"betriebssystemunabhaengige-pfad-und-verzeichnisnamen\">Betriebssystemunabh\u00e4ngige  Pfad- und Verzeichnisnamen<\/h3>\n\n\n\n<p>Wie in der Tabelle gesehen, beginnen absolute Pfade unter Windows mit einem Laufwerksbuchstaben und einem Doppelpunkt, Verzeichnisse werden durch einen Backslash ('\\') getrennt. Unter Linux und Mac beginnen absolute Pfade mit einem Schr\u00e4gstrich bzw. Forward Slash ('\/'), und durch selbigen werden auch Verzeichnisse separiert.<\/p>\n\n\n\n<p>\u00dcber die Konstante <code>File.separator<\/code> oder die Methode <code>FileSystems.getDefault().getSeparator()<\/code> kann man auf das Trennzeichen des aktuell verwendeten Betriebssystems zugreifen und somit Pfadnamen \"manuell\" (also durch das Verketten von Strings) erzeugen. Beispielsweise so:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-2\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String homePath = System.getProperty(<span class=\"hljs-string\">\"user.home\"<\/span>);\nString fileName = <span class=\"hljs-string\">\"test\"<\/span> + System.currentTimeMillis();\nString filePath = homePath + File.separator + fileName;\nSystem.out.println(<span class=\"hljs-string\">\"filePath = \"<\/span> + filePath);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-2\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Je nach Betriebssystem bekommen wir eine unterschiedliche Ausgabe:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Windows: <code>filePath = C:\\Users\\svenw\\test1578950760671<\/code><\/li>\n\n\n\n<li>Linux: <code>filePath = \/home\/sven\/test1578950836130<\/code><\/li>\n<\/ul>\n\n\n\n<p>Beim <em>home<\/em>-Verzeichnis funktioniert das noch ganz gut, beim <em>temp<\/em>-Verzeichnis hingegen (dies bekommen wir \u00fcber die System Property \"java.io.tmpdir\") erhalten wir folgende Ausgaben:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Windows: <code>filePath = C:\\Users\\svenw\\AppData\\Local\\Temp\\\\test1578950862590<\/code><\/li>\n\n\n\n<li>Linux: <code>filePath = \/tmp\/test1578950884314<\/code><\/li>\n<\/ul>\n\n\n\n<p>Hast du das Problem entdeckt? <\/p>\n\n\n\n<p>Unter Windows endet der Pfad f\u00fcr das tempor\u00e4re Verzeichnis bereits mit einem Backslash. Durch das Hinzuf\u00fcgen eines Separators erzeugt unser Code einen doppelten Backslash im Dateipfad.<\/p>\n\n\n\n<p>Wir k\u00f6nnten nun pr\u00fcfen, ob der Verzeichnisname bereits mit einem Separator endet und diesen nur hinzuf\u00fcgen, wenn er nicht vorhanden ist. Das ist jedoch gar nicht n\u00f6tig. Man kann Datei- und Verzeichnisnamen wesentlich eleganter konstruieren \u2013 komplett ohne String-Operationen, und zwar mit Hilfe der Klassen <code>java.io.File<\/code> und (ab Java 7) <code>java.nio.file.Path<\/code>.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"alte-java-file-api-vs-nio-2-file-api\">\"Alte\" Java File API vs. NIO.2 File API<\/h3>\n\n\n\n<p>In Java 7 wurde mit dem <a rel=\"noopener\" href=\"https:\/\/jcp.org\/en\/jsr\/detail?id=203\" target=\"_blank\">JSR 203<\/a> die \"NIO.2 File API\" eingef\u00fchrt (NIO steht dabei f\u00fcr \"New I\/O\"). Diese stellt eine ganze Reihe neuer Klassen zum Umgang mit Dateien zur Verf\u00fcgung (vorgestellt in den vorangegangenen Artikel \u00fcber das <a href=\"\/de\/java\/dateien-schnell-einfach-schreiben\/\">Schreiben von Dateien<\/a> und das <a href=\"\/de\/java\/dateien-einfach-schnell-lesen\/\">Lesen von Dateien<\/a>). <\/p>\n\n\n\n<p>Dateien und Verzeichnisse wurden zuvor \u00fcber die Klasse <code>java.io.File<\/code> repr\u00e4sentiert. Dies f\u00fchrt insbesondere bei Anf\u00e4ngern zu Verwirrung, da der Klassenname eben darauf schlie\u00dfen l\u00e4sst, dass diese nur Dateien repr\u00e4sentiert, keine Verzeichnisse. <\/p>\n\n\n\n<p>In NIO.2 \u00fcbernimmt diese Aufgabe die \u2013 nun passender benannte \u2013 Klasse <code>java.nio.file.Path<\/code>, deren Schnittstelle im Vergleich zu <code>java.io.File<\/code> komplett neugeschrieben wurde.<\/p>\n\n\n<div class=\"convertkit-form wp-block-convertkit-form\" style=\"\"><script async data-uid=\"1427197203\" src=\"https:\/\/happycoders.kit.com\/1427197203\/index.js\" data-jetpack-boost=\"ignore\" data-no-defer=\"1\" data-no-optimize=\"1\" nowprocket><\/script><\/div>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"datei-und-verzeichnispfaden-konstruieren-mit-java-io-file\">Datei- und Verzeichnispfaden konstruieren mit java.io.File<\/h2>\n\n\n\n<p>Beginnen wir mit der \"alten\" Klasse, <code>java.io.File<\/code>. Ein <code>File<\/code>-Objekt kann einen Dateinamen, einen Verzeichnisnamen, einen relativen Datei- oder Verzeichnispfad oder einen absoluten Datei- oder Verzeichnispfad darstellen (wobei ein Datei-\/Verzeichnisname eigentlich auch ein relativer Datei-\/Verzeichnispfad ist, relativ zu demjenigen Verzeichnis, in dem sich die Datei\/das Verzeichnis befindet).<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"java-io-file-datei-und-verzeichnisnamen\">java.io.File: Datei- und Verzeichnisnamen<\/h3>\n\n\n\n<h4 class=\"wp-block-heading\">Dateiname mit java.io.File darstellen<\/h4>\n\n\n\n<p>Einen Dateinamen (ohne Angabe eines Verzeichnisses) definierst du bspw. wie folgt (wir bleiben beim oben verwendeten Muster <em>\"test&lt;Zeitstempel&gt;\"<\/em>:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-3\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">File file = <span class=\"hljs-keyword\">new<\/span> File(<span class=\"hljs-string\">\"test\"<\/span> + System.currentTimeMillis());<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-3\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Du kannst nun u. a. folgende Informationen aus dem <code>File<\/code>-Objekt auslesen:<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-stripes\"><table><thead><tr><th>Methode<\/th><th>R\u00fcckgabewert<\/th><\/tr><\/thead><tbody><tr><td><code>file.getName()<\/code><\/td><td><code>test1578953190701<\/code><\/td><\/tr><tr><td><code>file.getPath()<\/code><\/td><td><code>test1578953190701<\/code><\/td><\/tr><tr><td><code>file.getParent()<\/code> \/ <code>file.getParentFile()<\/code><\/td><td><code>null<\/code><\/td><\/tr><tr><td><code>file.getAbsolutePath()<\/code> \/ <code>file.getAbsoluteFile()<\/code><\/td><td><code>\/happycoders\/git\/filedemo\/test1578953190701<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p>Die Methode <code>getName()<\/code> liefert den Dateinamen zur\u00fcck, den wir dem Konstruktor \u00fcbergeben haben. <code>getPath()<\/code> liefert den Pfad, der in diesem Fall dem Dateinamen entspricht, da wir kein Verzeichnis angegeben haben. Aus dem gleichen Grund liefern <code>getParent()<\/code> und <code>getParentFile()<\/code> jeweils <code>null<\/code> zur\u00fcck, wobei die erste Methode einen <code>String<\/code> zur\u00fcckliefert, die zweite ein entsprechendes <code>File<\/code>-Objekt. <\/p>\n\n\n\n<p>Mit den Methoden <code>getAbsolutPath()<\/code> und <code>getAbsolutFile()<\/code> setzt du diese Datei sozusagen in das aktuelle Arbeitsverzeichnis und erh\u00e4lst den kompletten Pfad der Datei einschlie\u00dflich Verzeichnis- und Dateiname. Auch diese zwei Methoden unterscheiden sich nur dadurch, dass die erste einen <code>String<\/code> zur\u00fcckliefert und die zweite ein entsprechendes <code>File<\/code>-Objekt.<\/p>\n\n\n\n<p>Es gibt noch die Methoden <code>getCanonicalPath()<\/code> und <code>getCanonicalFile()<\/code>, welche in diesem und den folgenden Beispielen dieselben Werte zur\u00fcckliefern w\u00fcrden wie <code>getAbsolutePath()<\/code> und <code>getAbsoluteFile()<\/code>. Wir sehen in einem sp\u00e4teren Beispiel, in welchem Fall diese auch andere Werte enthalten k\u00f6nnen.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Verzeichnisname mit java.io.File darstellen<\/h4>\n\n\n\n<p>Das im vorangegangenen Abschnitt konstruierte <code>File<\/code>-Objekt k\u00f6nnte statt einer Datei ebensogut ein Verzeichnis mit demselben Namen repr\u00e4sentieren. Die in der Tabelle oben aufgelisteten Methoden w\u00fcrden dabei dieselben Ergebnisse liefern.<\/p>\n\n\n\n<p>Eine Unterscheidung w\u00e4re nur dann m\u00f6glich, falls bereits eine Datei oder ein Verzeichnis mit diesem Namen existiert. Falls eine entsprechende <em>Datei<\/em> existiert, w\u00fcrde die Methode <code>file.isFile()<\/code> den Wert <code>true<\/code> zur\u00fcckliefern. Existiert hingegen ein <em>Verzeichnis<\/em> mit diesem Namen, w\u00fcrde die Methode <code>file.isDirectory()<\/code> den Wert <code>true<\/code> liefern. Existieren <em>weder<\/em> Datei noch Verzeichnis, geben beide Methoden <code>false<\/code> zur\u00fcck. Je nach weiterer Verwendung kann das <code>File<\/code>-Objekt dann entweder zum Anlegen eines Verzeichnis oder zum Erstellen einer Datei verwendet werden.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"java-io-file-relative-datei-und-verzeichnispfade\">java.io.File: relative Datei- und Verzeichnispfade<\/h3>\n\n\n\n<h4 class=\"wp-block-heading\">Relativer Dateipfad mit java.io.File<\/h4>\n\n\n\n<p>Um ein Verzeichnis mit anzugeben, k\u00f6nnen wir dieses dem <code>File<\/code>-Konstruktor als Parameter \u00fcbergeben \u2013 in der einfachsten Form als String. Mit folgendem Code legst du die Testdatei in ein <code>tests<\/code>-Verzeichnis:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-4\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">File file = <span class=\"hljs-keyword\">new<\/span> File(<span class=\"hljs-string\">\"tests\"<\/span>, <span class=\"hljs-string\">\"test\"<\/span> + System.currentTimeMillis());<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-4\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Die Getter liefern nun folgende Informationen \u00fcber das <code>File<\/code>-Objekt (die Unterschiede zum vorherigen Beispiel sind <strong>fett<\/strong> hervorgehoben):<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-stripes\"><table><thead><tr><th>Methode<\/th><th>R\u00fcckgabewert<\/th><\/tr><\/thead><tbody><tr><td><code>file.getName()<\/code><\/td><td><code>test1578953190701<\/code><\/td><\/tr><tr><td><code>file.getPath()<\/code><\/td><td><code><strong>tests\/<\/strong>test1578953190701<\/code><\/td><\/tr><tr><td><code>file.getParent()<\/code> \/ <code>file.getParentFile()<\/code><\/td><td><code><strong>tests<\/strong><\/code><\/td><\/tr><tr><td><code>file.getAbsolutePath()<\/code> \/ <code>file.getAbsoluteFile()<\/code><\/td><td><code>\/happycoders\/git\/filedemo\/<strong>tests\/<\/strong>test1578953190701<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p>Jetzt sehen wir einen Unterschied zwischen <code>getName()<\/code> und <code>getPath()<\/code>: die erste Methode liefert nur den Dateinamen ohne die Verzeichnisangabe, die zweite Methode liefert den kompletten relativen Pfad. <code>getParent()<\/code> und <code>getParentFile()<\/code> (zur Erinnerung: die erste Methode liefert einen String, die zweite ein entsprechendes <code>File<\/code>-Objekt) liefern nun das angegebene Verzeichnis <code>tests<\/code> zur\u00fcck. In den absoluten Pfadangaben, die von <code>getAbsolutePath()<\/code> und <code>getAbsoluteFile()<\/code> zur\u00fcckgegeben werden (auch hier: String vs. File), ist entsprechend das Unterverzeichnis <code>tests<\/code> eingef\u00fcgt.<\/p>\n\n\n\n<p>Das Verzeichnis kann anstatt als <code>String<\/code> auch als <code>File<\/code>-Objekt \u00fcbergeben werden:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-5\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">File directory = <span class=\"hljs-keyword\">new<\/span> File(<span class=\"hljs-string\">\"tests\"<\/span>);\nFile file = <span class=\"hljs-keyword\">new<\/span> File(directory, <span class=\"hljs-string\">\"test\"<\/span> + System.currentTimeMillis());<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-5\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h4 class=\"wp-block-heading\">Relativer Dateipfad mit verschachtelten Verzeichnissen<\/h4>\n\n\n\n<p>Es k\u00f6nnen auch mehrere Verzeichnis-Ebenen verschachtelt werden:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-6\" data-shcb-language-name=\"GLSL\" data-shcb-language-slug=\"glsl\"><span><code class=\"hljs language-glsl\">File testsDirectory = new File(\"tests\");\nFile yearDirectory = new File(testsDirectory, \"<span class=\"hljs-number\">2020<\/span>\");\nFile dayDirectory = new File(yearDirectory, \"<span class=\"hljs-number\">2020<\/span><span class=\"hljs-number\">-01<\/span><span class=\"hljs-number\">-13<\/span>\");\nFile file = new File(dayDirectory, \"test\" + System.currentTimeMillis());<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-6\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">GLSL<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">glsl<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Somit k\u00f6nnen wir beliebig tiefe Verzeichnispfade konstruieren, ohne auch nur ein einziges Mal das Separatorzeichen verwenden zu m\u00fcssen. Das Beispiel konstruiert ein <code>File<\/code>-Objekt mit dem Pfad <code>tests\/2020\/2020-01-13\/test1578953190701<\/code>. <\/p>\n\n\n\n<p>Was wird hier die Methode <code>getParent()<\/code> zur\u00fcckliefern? <code>tests\/2020\/2020-01-13<\/code> oder nur <code>2020-01-13<\/code>? Probieren wir es aus...<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-stripes\"><table><thead><tr><th>Methode<\/th><th>R\u00fcckgabewert<\/th><\/tr><\/thead><tbody><tr><td><code>file.getName()<\/code><\/td><td><code>test1578953190701<\/code><\/td><\/tr><tr><td><code>file.getPath()<\/code><\/td><td><code><strong>tests\/2020\/2020-01-13\/<\/strong>test1578953190701<\/code><\/td><\/tr><tr><td><code>file.getParent()<\/code> \/ <code>file.getParentFile()<\/code><\/td><td><code><strong>tests\/2020\/2020-01-13<\/strong><\/code><\/td><\/tr><tr><td><code>file.getAbsolutePath()<\/code> \/ <code>file.getAbsoluteFile()<\/code><\/td><td><code>\/happycoders\/git\/filedemo\/<strong>tests\/2020\/2020-01-13\/<\/strong>test1578953190701<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p>Der Parent repr\u00e4sentiert also den Pfad zum Elternverzeichnis, nicht nur dessen Namen. Auf den Namen des Elternverzeichnisses k\u00f6nnen wir \u00fcber <code>file.getParentFile().getName()<\/code> zugreifen.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Relativer Verzeichnispfad mit java.io.File<\/h4>\n\n\n\n<p>Auch in den Beispielen aus dem vorangegangenen Abschnitt k\u00f6nnte <code>test1578953190701<\/code> statt einer Datei ein Verzeichnis sein. Der Pfad l\u00e4sst hierauf keine R\u00fcckschl\u00fcsse zu.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"java-io-file-absolute-datei-und-verzeichnispfade\">java.io.File: absolute Datei- und Verzeichnispfade<\/h3>\n\n\n\n<h4 class=\"wp-block-heading\">Absoluter Verzeichnispfad mit java.io.File<\/h4>\n\n\n\n<p>Achtung: Die absoluten Pfade betrachten wir in umgekehrter Reihenfolge: Wir konstruieren zuerst den <em>Verzeichnis<\/em>pfad und dann den <em>Datei<\/em>pfad, da wir ohne absoluten Verzeichnispfad als Parent keinen absoluten Dateipfad generieren k\u00f6nnen.<\/p>\n\n\n\n<p>(Es gibt eine Ausnahme, die wir in den bisheringen Beispielen bereits kennengelernt haben: Den absoluten Dateipfad f\u00fcr eine Datei <em>im aktuellen Verzeichnis<\/em> erhalten wir, in dem wir den <code>File<\/code>-Konstruktor mit nur dem Dateinamen aufrufen und auf dem erzeugten <code>File<\/code>-Objekt dann die Methode <code>getAbsoluteFile()<\/code> \/ <code>getAbsolutePath()<\/code> aufrufen.)<\/p>\n\n\n\n<p>Folgende M\u00f6glichkeiten haben wir, um einen absoluten <em>Verzeichnis<\/em>pfad zu konstruieren:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>aus einem als String dargestellten (und damit betriebssystemabh\u00e4ngigen) absoluten Verzeichnispfad<\/li>\n\n\n\n<li>aus den zu Beginn erw\u00e4hnten System Properties wie \"user.home\" und \"java.io.tmpdir\"<\/li>\n\n\n\n<li>aus dem aktuellen Verzeichnis<\/li>\n<\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">Absoluten Verzeichnispfad aus einem String erzeugen<\/h4>\n\n\n\n<p>Haben wir den absoluten Verzeichnispfad in einem String (beispielsweise aus einer Konfigurationsdatei), k\u00f6nnen wir diesen direkt an den <code>File<\/code>-Konstruktor \u00fcbergeben. Folgendes Beispiel verwendet der Einfachheit halber eine String-Konstante:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-7\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">File directory = <span class=\"hljs-keyword\">new<\/span> File(<span class=\"hljs-string\">\"\/var\/log\/myapp\"<\/span>);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-7\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>F\u00fcr dieses absolute Verzeichnis liefern die Getter des <code>File<\/code>-Objekts folgende R\u00fcckgabewerte:<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-stripes\"><table><thead><tr><th>Methode<\/th><th>R\u00fcckgabewert<\/th><\/tr><\/thead><tbody><tr><td><code>file.getName()<\/code><\/td><td><code>myapp<\/code><\/td><\/tr><tr><td><code>file.getPath()<\/code><\/td><td><code>\/var\/log\/myapp<\/code><\/td><\/tr><tr><td><code>file.getParent()<\/code> \/ <code>file.getParentFile()<\/code><\/td><td><code>\/var\/log<\/code><\/td><\/tr><tr><td><code>file.getAbsolutePath()<\/code> \/  <code>file.getAbsoluteFile() <\/code><\/td><td><code>\/var\/log\/myapp<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p>Die Methoden <code>getPath()<\/code>, <code>getAbsolutePath()<\/code> und <code>getAbsoluteFile()<\/code> liefern nun alle den absoluten Pfad des Verzeichnisses zur\u00fcck. <code>getParent()<\/code> und <code>getParentFile()<\/code> liefern den absoluten Pfad des Elternverzeichnisses.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Absoluten Verzeichnispfad aus System-Properties erzeugen<\/h4>\n\n\n\n<p>\u00dcber die System-Properties <code>user.home<\/code> bzw. <code>java.io.tmpdir<\/code> bekommt man \u2013 betriebssystemunabh\u00e4ngig \u2013 das Home-Verzeichnis des Users bzw. das tempor\u00e4re Verzeichnis. <\/p>\n\n\n\n<p>Die Methode <code>System.getProperty()<\/code> liefert letztendlich den Pfad auch als String zur\u00fcck, den wir dann wiederum dem <code>File<\/code>-Konstruktor \u00fcbergeben k\u00f6nnen. Oben haben wir gesehen, dass unter Windows das tempor\u00e4re Verzeichnis einen abschlie\u00dfenden Backslash hat, das Home-Verzeichnis nicht. Macht uns das an dieser Stelle Probleme?<\/p>\n\n\n\n<p>Mit folgendem Code k\u00f6nnen wir es unter Windows testen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-8\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">String homeDir = System.getProperty(<span class=\"hljs-string\">\"user.home\"<\/span>);\nSystem.out.println(<span class=\"hljs-string\">\"homeDir                = \"<\/span> + homeDir);\nSystem.out.println(<span class=\"hljs-string\">\"homeDir as File object = \"<\/span> + <span class=\"hljs-keyword\">new<\/span> File(homeDir));\n\nString tempDir = System.getProperty(<span class=\"hljs-string\">\"java.io.tmpdir\"<\/span>);\nSystem.out.println(<span class=\"hljs-string\">\"tempDir                = \"<\/span> + tempDir);\nSystem.out.println(<span class=\"hljs-string\">\"tempDir as File object = \"<\/span> + <span class=\"hljs-keyword\">new<\/span> File(tempDir));<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-8\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Das Programm gibt folgendes aus:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-9\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">homeDir                = C:\\Users\\svenw\nhomeDir as File object = C:\\Users\\svenw\ntempDir                = C:\\Users\\svenw\\AppData\\Local\\Temp\\\ntempDir as File object = C:\\Users\\svenw\\AppData\\Local\\Temp<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-9\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Der \u00fcberfl\u00fcssige abschlie\u00dfende Backslash wurde entfernt, wir m\u00fcssen uns also um nichts weiter k\u00fcmmern.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Absoluten Verzeichnispfad aus aktuellem Verzeichnis erzeugen<\/h4>\n\n\n\n<p>Mit dem bisherigen Wissen k\u00f6nnten wir wie folgt den absoluten Verzeichnispfad des aktuellen Verzeichnisses konstruieren:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-10\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">File file = <span class=\"hljs-keyword\">new<\/span> File(<span class=\"hljs-string\">\"dummy\"<\/span>);\nFile absoluteFile = file.getAbsoluteFile();\nFile absoluteDirectory = absoluteFile.getParentFile();<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-10\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Wir haben hier einen Dummy-Dateipfad generiert, f\u00fcr diesen den absoluten Pfad konstruiert (wodurch die Datei in das aktuelle Verzeichnis gesetzt wird) und daraus dann wiederum den Parent extrahiert \u2013 also den absoluten Pfad des Verzeichnisses, in dem die Datei liegt.<\/p>\n\n\n\n<p>Das ist zugegebenerma\u00dfen ziemlich umst\u00e4ndlich. Gl\u00fccklicherweise gibt es eine elegantere M\u00f6glichkeit: Das aktuelle Verzeichnis kann auch \u00fcber eine System-Property, <code>user.dir<\/code>, ausgelesen und dann dem <code>File<\/code>-Konstruktor \u00fcbergeben werden:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-11\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">File currentDir = <span class=\"hljs-keyword\">new<\/span> File(System.getProperty(<span class=\"hljs-string\">\"user.dir\"<\/span>));<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-11\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h4 class=\"wp-block-heading\">Absoluter Dateipfad mit java.io.File<\/h4>\n\n\n\n<p>Nachdem wir verschiedene Varianten betrachtet haben, wie ein absoluter Verzeichnispfad erstellt werden kann, k\u00f6nnen wir daraus nun einen absoluten Dateipfad konstruieren. Dazu m\u00fcssen wir lediglich dem <code>File<\/code>-Konstruktor Verzeichnis und Dateiname \u00fcbergeben.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-12\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">File tempDir = <span class=\"hljs-keyword\">new<\/span> File(System.getProperty(<span class=\"hljs-string\">\"java.io.tmpdir\"<\/span>));\nFile subDir = <span class=\"hljs-keyword\">new<\/span> File(tempDir, <span class=\"hljs-string\">\"myapp\"<\/span>);\nString fileName = <span class=\"hljs-string\">\"foo\"<\/span>;\nFile file = <span class=\"hljs-keyword\">new<\/span> File(subDir, fileName);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-12\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>F\u00fcr dieses Beispiel liefern die Getter des <code>File<\/code>-Objekts folgende R\u00fcckgabewerte:<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-stripes\"><table><thead><tr><th>Methode<\/th><th>R\u00fcckgabewert<\/th><\/tr><\/thead><tbody><tr><td><code>file.getName()<\/code><\/td><td><code>foo<\/code><\/td><\/tr><tr><td><code>file.getPath()<\/code><\/td><td><code>\/tmp\/myapp\/foo<\/code><\/td><\/tr><tr><td><code>file.getParent()<\/code> \/ <code>file.getParentFile()<\/code><\/td><td><code>\/tmp\/myapp<\/code><\/td><\/tr><tr><td><code>file.getAbsolutePath()<\/code> \/ <code>file.getAbsoluteFile()<\/code><\/td><td><code>\/tmp\/myapp\/foo<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p>Wir sehen ein \u00e4hnliches Muster wie bei dem Beispiel mit dem absoluten Verzeichnispfad <code>\/var\/log\/myapp<\/code>: Die Methoden <code>getPath()<\/code>, <code>getAbsolutePath()<\/code> und <code>getAbsoluteFile()<\/code> liefern den absoluten Pfad der Datei zur\u00fcck. Und <code>getParent()<\/code> und <code>getParentFile()<\/code> liefern den absoluten Pfad des Elternverzeichnisses.<\/p>\n\n\n\n<p class=\"has-very-light-gray-background-color has-background\"><strong>Achtung:<br><\/strong><br>Wenn du ein <code>File<\/code>-Objekt f\u00fcr eine Datei im aktuellen Verzeichnis erstellst, macht es einen Unterschied, ob du das Objekt mit dem aktellen Verzeichnis und dem Dateinamen erzeugst oder nur mit dem Dateinamen. Die Methoden <code>getAbsoluteFile()<\/code> \/ <code>getAbsolutePath()<\/code> liefern zwar in beiden F\u00e4llen den absoluten Dateipfad zur\u00fcck. Allerdings liefert <code>getPath()<\/code> nur im ersten Fall den absoluten Pfad zur\u00fcck, im zweiten lediglich den Dateinamen. Und getParent() und getParentFile() liefern nur im ersten Fall das Elternverzeichnis zur\u00fcck, im zweiten hingegen <code>null<\/code>.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"java-io-file-uebersicht-der-file-getter-methoden\">java.io.File: \u00dcbersicht der File-Getter-Methoden<\/h3>\n\n\n\n<p>Die folgende Tabelle zeigt zusammengefasst, was die File-Getter abh\u00e4ngig vom repr\u00e4sentierten Dateisystem-Objekt jeweils zur\u00fcckliefern:<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-stripes\"><table><thead><tr><th>Methode<\/th><th>Datei-\/Verzeichnisname<\/th><th>relativer Datei-\/Verzeichnispfad<\/th><th>absoluter Datei-\/Verzeichnispfad<\/th><th><\/th><th><\/th><\/tr><\/thead><tbody><tr><td><code>getName()<\/code><\/td><td>Datei-\/Verzeichnisname<\/td><td>Datei-\/Verzeichnisname<\/td><td>Datei-\/Verzeichnisname<\/td><td><\/td><td><\/td><\/tr><tr><td><code>getPath()<\/code><\/td><td>Datei-\/Verzeichnisname<\/td><td>relativer Datei-\/Verzeichnispfad<\/td><td>absoluter Datei-\/Verzeichnispfad<\/td><td><\/td><td><\/td><\/tr><tr><td><code>getParent()<\/code> \/ <code>getParentFile()<\/code><\/td><td><code>null <\/code><\/td><td>relativer Pfad zum Elternverzeichnis<\/td><td>absoluter Pfad zum Elternverzeichnis<\/td><td><\/td><td><\/td><\/tr><tr><td><code>getAbsolutePath()<\/code> \/ <code>getAbsoluteFile()<\/code><\/td><td>Absoluter Pfad aus Kombination von aktuellem Verzeichnis und Datei-\/Verzeichnisname<\/td><td>Absoluter Pfad aus Kombination von aktuellem Verzeichnis und relativem Datei-\/Verzeichnispfad<\/td><td>absoluter Datei-\/Verzeichnispfad<\/td><td><\/td><td><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p>Noch einmal zur Erinnerung: <code>getParent()<\/code> und <code>getAbsolutePath()<\/code> liefern einen String; <code>getParentFile()<\/code> und <code>getAbsoluteFile()<\/code> ein entsprechendes <code>File<\/code>-Objekt.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"java-io-file-was-ist-der-unterschied-zwischen-getcanonicalpath-getcanonicalfile-und-getabsolutepath-getabsolutepath\">java.io.File: Was ist der Unterschied zwischen getCanonicalPath() \/ getCanonicalFile() und getAbsolutePath() \/ getAbsolutePath()?<\/h3>\n\n\n\n<p>In allen bisherigen Beispielen h\u00e4tten die Methoden <code>getCanonicalPath()<\/code> und <code>getCanonicalFile()<\/code> das gleiche Ergebnis geliefert wie <code>getAbsolutePath()<\/code> und <code>getAbsoluteFile()<\/code> \u2013 n\u00e4mlich den jeweiligen absoluten Pfad (jeweils als String bzw. <code>File<\/code>-Objekt).<\/p>\n\n\n\n<p>Was also ist der Unterschied?<\/p>\n\n\n\n<p>Ein \"canonical path\" ist eindeutig, d. h. es gibt nur einen einzigen solchen Pfad zu einer Datei. Absolute Pfade hingegen kann es zu ein- und derselben Datei mehrere geben. Ein Beispiel:<\/p>\n\n\n\n<p>F\u00fcr die Datei <code>\/var\/log\/syslog<\/code> ist eben dieser String auch der \"canonical path\". Derselbe String ist auch ein absoluter Pfad. Es gibt allerdings noch weitere absolute Pfade, wie beispielsweise:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><code>\/var\/log\/.\/syslog<\/code>,<\/li>\n\n\n\n<li><code>\/var\/log\/..\/log\/syslog<\/code>,<\/li>\n\n\n\n<li><code>\/home\/user\/..\/..\/var\/log\/syslog<\/code>,<\/li>\n\n\n\n<li>sowie alle Pfade, die \u00fcber symbolischen Links letztendlich zu <code>\/var\/log\/syslog<\/code> zeigen.<\/li>\n<\/ul>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"konstruktion-von-datei-und-verzeichnispfaden-mit-java-nio-file-path-und-paths\">Konstruktion von Datei- und Verzeichnispfaden mit java.nio.file.Path und Paths<\/h2>\n\n\n\n<p>Obwohl die Schnittstelle von <code>java.nio.file.Path<\/code> gegen\u00fcber <code>java.io.File<\/code> komplett ge\u00e4ndert wurde, sind die dahinter liegenden Konzepte unver\u00e4ndert geblieben. Nach wie vor k\u00f6nnen Dateinamen, Verzeichnisnamen, relative Datei- und Verzeichnispfade sowie absolute Datei- und Verzeichnispfad repr\u00e4sentiert werden.<\/p>\n\n\n\n<p>Was wurde ge\u00e4ndert? In den folgenden Abschnitten seht ihr, wie <code>Path<\/code>-Objekte konstruiert werden \u2013 und zwar in der gleichen Struktur und anhand der gleichen Beispiele wie zuvor die <code>File<\/code>-Objekte.<\/p>\n\n\n\n<p>Auf die Unterscheidung in Datei- und Verzeichnisnamen verzichte ich im Folgenden. Wir haben oben bereits festgestellt, dass, solange das entsprechende Dateisystem-Objekt noch nicht existiert, aus dessen Pfad nicht erkennbar ist, ob es sich um eine Datei oder ein Verzeichnis handelt.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"java-nio-file-path-datei-und-verzeichnisnamen\">java.nio.file.Path: Datei- und Verzeichnisnamen<\/h3>\n\n\n\n<p>Statt eines Konstruktors verwenden wir bei <code>java.nio.file.Path<\/code> eine Factory-Methode, um Instanzen zu erzeugen. Diese befand sich urspr\u00fcnglich in der Klasse <code>java.nio.file.Paths<\/code> (mit \"s\" am Ende), sie wurde in Java 11 dann auch direkt in die <code>Path<\/code>-Klasse mit aufgenommen. Ein <code>Path<\/code>-Objekt f\u00fcr den Dateinamen <em>\"test&lt;Zeitstempel&gt;\"<\/em> erstellen wir wie folgt:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-13\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">Path path = Paths.get(<span class=\"hljs-string\">\"test\"<\/span> + System.currentTimeMillis());<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-13\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Ab Java 11 kannst du statt <code>Paths.get()<\/code> auch <code>Path.of()<\/code> verwenden. Einen Unterschied gibt es nicht. Intern ruft <code>Paths.get()<\/code> die neuere Methode <code>Path.of()<\/code> auf und diese wiederum <code>FileSystems.getDefault().getPath()<\/code>.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-14\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">Path path = Path.of(<span class=\"hljs-string\">\"test\"<\/span> + System.currentTimeMillis());<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-14\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Folgende Methoden liefern Informationen analog zu den zuvor gezeigten Methoden der <code>File<\/code>-Klasse:<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-stripes\"><table><thead><tr><th>Methode<\/th><th>R\u00fcckgabewert<\/th><\/tr><\/thead><tbody><tr><td><code>path.getFileName()<\/code><\/td><td><code>test1579037366379<\/code><\/td><\/tr><tr><td><code>path.getNameCount()<\/code><\/td><td><code>1<\/code><\/td><\/tr><tr><td><code>path.getName(0)<\/code><\/td><td><code>test1579037366379<\/code><\/td><\/tr><tr><td><code>path.getParent()<\/code><\/td><td><code>null<\/code><\/td><\/tr><tr><td><code>path.getRoot()<\/code><\/td><td><code>null<\/code><\/td><\/tr><tr><td><code>path.toAbsolutePath()<\/code><\/td><td><code>\/happycoders\/git\/filedemo\/test1579037366379<\/code><\/td><\/tr><tr><td><code>path.normalize()<\/code><\/td><td> <code>test1579037366379 <\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p>Zun\u00e4chst einmal: Alle gezeigten Methoden \u2013 mit Ausnahme von <code>getNameCount()<\/code> \u2013 liefern wiederum ein <code>Path<\/code>-Objekt zur\u00fcck. Es gibt keine Varianten dieser Methoden, die einen String zur\u00fcckliefern. Die einzige M\u00f6glichkeit ein <code>Path<\/code>-Objekt in einen String umzuwandeln, ist dessen <code>toString()<\/code>-Methode aufzurufen.<\/p>\n\n\n\n<p>Die Methode <code>getFileName()<\/code> liefert den Datei- bzw. Verzeichnisnamen zur\u00fcck. <code>getNameCount()<\/code> ist bei einem Dateinamen ohne Verzeichnisangabe, bzw. bei Verzeichnissen ohne Elternverzeichnis immer 1. Und der erste Name, abrufbar durch <code>getName(0)<\/code>, ist ebenfalls der Datei-\/Verzeichnisname. <code>getParent()<\/code> liefert \u2013 wie die gleichnamige <code>File<\/code>-Methode \u2013 <code>null<\/code> zur\u00fcck. Die Methode <code>getRoot()<\/code> liefert ebenfalls <code>null<\/code>, da ein einzelner Dateiname immer relativ ist. Mit <code>toAbsolutePath()<\/code> setzen wir \u2013 analog zu <code>File.getAbsolutePath()<\/code> \u2013 die Datei\/das Verzeichnis ins aktuelle Vezeichnis und erhalten den entsprechenden absoluten Pfad.<\/p>\n\n\n\n<p><code>Path.normalize()<\/code> ist vergleichbar mit <code>File.getCanonicalPath()<\/code> mit dem Unterschied, dass bei der Normalisierung eines Pfades relative Pfade relativ bleiben, w\u00e4hrend <code>getCanonicalPath()<\/code> sowohl f\u00fcr absolute als auch f\u00fcr relative <code>File<\/code>-Objekte grunds\u00e4tzlich einen absoluten Pfad generiert.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"java-nio-file-path-relative-datei-und-verzeichnispfade\">java.nio.file.Path: relative Datei- und Verzeichnispfade<\/h3>\n\n\n\n<p>Um Verzeichnisse mit anzugeben, gibt es bei <code>Path<\/code> zwei M\u00f6glichkeiten:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>du kannst alle Verzeichnisse in der Factory-Methode <code>Paths.get()<\/code> bzw. <code>Path.of()<\/code> auflisten;<\/li>\n\n\n\n<li>du kannst ein existierendes <code>Path<\/code>-Objekt mit dessen <code>resolve()<\/code>-Methode in ein neues <code>Path<\/code>-Objekt \u00fcberf\u00fchren, wobei die <code>resolve()<\/code>-Methode dem Wechseln des Verzeichnisses mit dem Windows- bzw. Linux-Kommando <code>cd<\/code> entspricht.<\/li>\n<\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">Relative Datei- und Verzeichnispfade mit Paths.get() \/ Path.of() konstruieren<\/h4>\n\n\n\n<p>Den Factory-Methoden kannst du beliebig viele Verzeichnisnamen \u00fcbergeben. Den relativen Pfad <code>tests\/test1578953190701<\/code> bspw. w\u00fcrdest du wie folgt konstruieren (der Zeitstempel ist hier der Einfachheit halber hartkodiert):<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-15\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">Path path = Paths.get(<span class=\"hljs-string\">\"tests\"<\/span>, <span class=\"hljs-string\">\"test1578953190701\"<\/span>);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-15\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Die Getter dieses <code>Path<\/code>-Objekts liefern folgende Resultate (die Unterschiede zum einzelnen Dateinamen habe ich wieder <strong>fett<\/strong> hervorgehoben):<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-stripes\"><table><thead><tr><th>Methode<\/th><th>R\u00fcckgabewert<\/th><\/tr><\/thead><tbody><tr><td><code>path.getFileName()<\/code><\/td><td><code>test1578953190701<\/code><\/td><\/tr><tr><td><code>path.getNameCount()<\/code><\/td><td><code><strong>2<\/strong><\/code><\/td><\/tr><tr><td><code>path.getName(0)<\/code><\/td><td><code><strong>tests<\/strong><\/code><\/td><\/tr><tr><td><code>path.getName(1)<\/code><\/td><td><code>test1578953190701<\/code><\/td><\/tr><tr><td><code>path.getParent()<\/code><\/td><td> <code><strong>tests<\/strong><\/code><\/td><\/tr><tr><td><code>path.getRoot()<\/code><\/td><td><code>null<\/code><\/td><\/tr><tr><td><code>path.toAbsolutePath()<\/code><\/td><td><code>\/happycoders\/git\/filedemo\/<strong>tests\/<\/strong>test1578953190701<\/code><\/td><\/tr><tr><td><code>path.normalize()<\/code><\/td><td><code><strong>tests\/<\/strong>test1578953190701<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p>Durch das Verzeichnis hat sich der <code>nameCount<\/code> von 1 auf 2 erh\u00f6ht. In dem <code>name<\/code>-Array wurde an Position 0 der Verzeichnisname eingef\u00fcgt, der Dateiname ist auf Position 1 gerutscht. <code>getParent()<\/code> liefert ebenfalls den Verzeichnisnamen zur\u00fcck. Ebenso sind im absoluten Pfad sowie in der normalisierten Version der Verzeichnisname enthalten.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Verschachtelte Datei- und Verzeichnispfade mit Paths.get() \/ Path.of() konstruieren<\/h4>\n\n\n\n<p>Soll die Datei im Verzeichnis <code>tests\/2020\/2020-01-13<\/code> liegen, wird die Factory-Methode wie folgt aufgerufen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-16\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">Path path = Paths.get(<span class=\"hljs-string\">\"tests\"<\/span>, <span class=\"hljs-string\">\"2020\"<\/span>, <span class=\"hljs-string\">\"2020-01-13\"<\/span>, <span class=\"hljs-string\">\"test1578953190701\"<\/span>);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-16\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Hier auch daf\u00fcr noch einmal die Getter-Resultate:<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-stripes\"><table><thead><tr><th>Methode<\/th><th>R\u00fcckgabewert<\/th><\/tr><\/thead><tbody><tr><td><code>path.getFileName()<\/code><\/td><td><code>test1578953190701<\/code><\/td><\/tr><tr><td><code>path.getNameCount()<\/code><\/td><td><code><strong>4<\/strong><\/code><\/td><\/tr><tr><td><code>path.getName(0)<\/code><\/td><td><code><strong>tests<\/strong><\/code><\/td><\/tr><tr><td><code>path.getName(1)<\/code><\/td><td><code><strong>2020<\/strong><\/code><\/td><\/tr><tr><td><code>path.getName(2)<\/code><\/td><td><code><strong>2020-01-13<\/strong><\/code><\/td><\/tr><tr><td><code>path.getName(3)<\/code><\/td><td><code>test1578953190701<\/code><\/td><\/tr><tr><td><code>path.getParent()<\/code><\/td><td><code><strong>tests\/2020\/2020-01-13<\/strong><\/code><\/td><\/tr><tr><td><code>path.getRoot()<\/code><\/td><td><code>null<\/code><\/td><\/tr><tr><td><code>path.toAbsolutePath()<\/code><\/td><td><code>\/happycoders\/git\/filedemo\/<strong>tests\/2020\/2020-01-13\/<\/strong>test1578953190701<\/code><\/td><\/tr><tr><td><code>path.normalize()<\/code><\/td><td><code><strong>tests\/2020\/2020-01-13\/<\/strong>test1578953190701<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p>Der <code>nameCount<\/code> ist entsprechend erh\u00f6ht und das <code>name<\/code>-Array enth\u00e4lt alle Verzeichnisse des Pfades sowie den Dateinamen. Auch hier liefert <code>getParent()<\/code> den kompletten bekannten Pfad zum Verzeichnis zur\u00fcck, nicht nur dessen Namen.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">Relative Datei- und Verzeichnispfade mit Path.resolve() konstruieren<\/h4>\n\n\n\n<p>Eine alternative M\u00f6glichkeit, um das <code>Path<\/code>-Objekt f\u00fcr den Pfad <code>tests\/2020\/2020-01-13\/test1578953190701<\/code> zu konstruieren ist die Nutzung der resolve()-Methode. Diese kombiniert den Pfad, auf der die Methode aufgerufen wird, mit dem ihr \u00fcbergebenen Pfad:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-17\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">Path testsDir = Paths.get(<span class=\"hljs-string\">\"tests\"<\/span>);\nPath yearDir = testsDir.resolve(<span class=\"hljs-string\">\"2020\"<\/span>);\nPath dayDir = yearDir.resolve(<span class=\"hljs-string\">\"2020-01-13\"<\/span>);\nPath path = dayDir.resolve(<span class=\"hljs-string\">\"test1578953190701\"<\/span>);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-17\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Die <code>resolve()<\/code>-Verkn\u00fcpfung ist assoziativ, d. h. die einzelnen Teile k\u00f6nnen auch in anderer Reihenfolge verbunden werden, z. B. so:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-18\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">Path testsDir = Paths.get(<span class=\"hljs-string\">\"tests\"<\/span>); <span class=\"hljs-comment\">\/\/ tests<\/span>\nPath yearDir = testsDir.resolve(<span class=\"hljs-string\">\"2020\"<\/span>); <span class=\"hljs-comment\">\/\/ tests\/2020<\/span>\nPath dayDir = Paths.get(<span class=\"hljs-string\">\"2020-01-13\"<\/span>); <span class=\"hljs-comment\">\/\/ 2020-01-13<\/span>\n\n<span class=\"hljs-comment\">\/\/ 2020-01-13\/test1578953190701<\/span>\nPath fileInDayDir = dayDir.resolve(<span class=\"hljs-string\">\"test1578953190701\"<\/span>);\n\n<span class=\"hljs-comment\">\/\/ tests\/2020\/2020-01-13\/test1578953190701<\/span>\nPath path = yearDir.resolve(fileInDayDir);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-18\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h4 class=\"wp-block-heading\">Shortcut: Path.resolveSibling()<\/h4>\n\n\n\n<p>Nehmen wir an, wir haben das <code>Path<\/code>-Objekt, dass wir im vorherigen Abschnitt konstruiert haben und m\u00f6chten im gleichen Verzeichnis eine weitere Datei anlegen. Wenn wir das <code>Path<\/code>-Objekt, dass das Verzeichnis repr\u00e4sentiert, noch zur Verf\u00fcgung haben, k\u00f6nnen wir darauf <code>resolve()<\/code> mit dem neuen Dateinamen aufrufen. Andernfalls k\u00f6nnten wir mit <code>getParent()<\/code> auf das Verzeichnis zugreifen und dann <code>resolve()<\/code> aufrufen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-19\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">Path sibling = path.getParent().resolve(<span class=\"hljs-string\">\"test\"<\/span> + System.currentTimeMillis());<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-19\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Genau f\u00fcr diesen Zweck gibt es die Abk\u00fcrzung <code>resolveSibling()<\/code>, die einem immerhin f\u00fcnf Tastaturanschl\u00e4ge und Bytes einspart:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-20\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">Path sibling = path.resolveSibling(<span class=\"hljs-string\">\"test\"<\/span> + System.currentTimeMillis());<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-20\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"java-nio-file-path-absolute-datei-und-verzeichnispfade\">java.nio.file.Path: absolute Datei- und Verzeichnispfade<\/h3>\n\n\n\n<p>Analog zu <code>java.io.File<\/code> k\u00f6nnen wir einen absoluten Pfad auch bei <code>java.nio.file.Path<\/code> aus einem String erzeugen, den wir aus einer Konfigurationsdatei oder aus einer System Property lesen.  Diesen k\u00f6nnen wir, so wie er ist, der Factory-Methode \u00fcbergeben. Wir brauchen ihn nicht erst aufzusplitten. Am Beispiel des Verzeichnisses <code>\/var\/log\/myapp<\/code>:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-21\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">Path path = Paths.get(<span class=\"hljs-string\">\"\/var\/log\/myapp\"<\/span>);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-21\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Nat\u00fcrlich k\u00f6nnen wir auch einen absoluten Pfad mit der <code>resolve()<\/code>-Methode ver\u00e4ndern. Folgendes Beispiel entspricht dem Beispiel des absoluten Dateipfads mit <code>java.io.File<\/code>:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-22\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">Path tempDir = Path.of(System.getProperty(<span class=\"hljs-string\">\"java.io.tmpdir\"<\/span>));\nPath subDir = tempDir.resolve(<span class=\"hljs-string\">\"myapp\"<\/span>);\nString fileName = <span class=\"hljs-string\">\"foo\"<\/span>;\nPath file = subDir.resolve(fileName);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-22\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>F\u00fcr diesen absoluten Pfad liefern die Getter-Methoden:<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-stripes\"><table><thead><tr><th>Methode<\/th><th>R\u00fcckgabewert<\/th><\/tr><\/thead><tbody><tr><td><code>path.getFileName()<\/code><\/td><td><code>foo<\/code><\/td><\/tr><tr><td><code>path.getNameCount()<\/code><\/td><td><code>3<\/code><\/td><\/tr><tr><td><code>path.getName(0)<\/code><\/td><td><code>tmp<\/code><\/td><\/tr><tr><td><code>path.getName(1)<\/code><\/td><td><code>myapp<\/code><\/td><\/tr><tr><td><code>path.getName(2)<\/code><\/td><td><code>foo<\/code><\/td><\/tr><tr><td><code>path.getParent()<\/code><\/td><td><code>\/tmp\/myapp<\/code><\/td><\/tr><tr><td><code>path.getRoot()<\/code><\/td><td><code>\/<\/code><\/td><\/tr><tr><td><code>path.toAbsolutePath()<\/code><\/td><td><code>\/tmp\/myapp\/foo<\/code><\/td><\/tr><tr><td><code>path.normalize()<\/code><\/td><td><code>\/tmp\/myapp\/foo<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p>Hier erleben wir zum ersten Mal, dass <code>path.getRoot()<\/code> nicht <code>null<\/code> zur\u00fcckliefert, sondern \"\/\", das Linux-Rootverzeichnis. Unter Windows erhalten wir hier \"C:\\\" (es sei denn das tempor\u00e4re Verzeichnis liegt in einem anderen Dateisystem). Das Root-Verzeichnis ist nicht Teil des <code>name<\/code>-Arrays.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"java-nio-file-path-uebersicht-der-getter-methoden\">java.nio.file.Path: \u00dcbersicht der Getter-Methoden<\/h3>\n\n\n\n<p>Hier siehst du noch einmal zusammengefasst, was die <code>Path<\/code>-Getter jeweils zur\u00fcckliefern:<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-stripes\"><table><thead><tr><th>Methode<\/th><th><strong>Datei-\/Verzeichnisname<\/strong><\/th><th><strong>relativer Datei-\/Verzeichnispfad<\/strong><\/th><th>absoluter <strong>Datei-\/Verzeichnispfad<\/strong><\/th><\/tr><\/thead><tbody><tr><td><code>path.getFileName()<\/code><\/td><td>Datei-\/Verzeichnisname<\/td><td>Datei-\/Verzeichnisname<\/td><td>Datei-\/Verzeichnisname<\/td><\/tr><tr><td><code>path.getNameCount()<\/code><\/td><td><code>1<\/code><\/td><td>Anzahl der Verzeichnisse + Datei<\/td><td>Anzahl der Verzeichnisse + Datei<\/td><\/tr><tr><td><code>path.getName(index)<\/code><\/td><td>Datei-\/Verzeichnisname<\/td><td>Datei-\/Verzeichnisnamen an der gegebenen Position (0-basiert)<\/td><td>Datei-\/Verzeichnisnamen an der gegebenen Position (0-basiert, Root z\u00e4hlt nicht mit)<\/td><\/tr><tr><td><code>path.getParent()<\/code><\/td><td><code>null<\/code><\/td><td>relativer Pfad zum Elternverzeichnis<\/td><td>absoluter Pfad zum Elternverzeichnis<\/td><\/tr><tr><td><code>path.getRoot()<\/code><\/td><td><code>null<\/code><\/td><td><code>null<\/code><\/td><td>Root des Dateisystems, z. B. \"\/\" oder \"C:\\\"<\/td><\/tr><tr><td><code>path.toAbsolutePath()<\/code><\/td><td>Absoluter Pfad aus Kombination von aktuellem Verzeichnis und Datei-\/Verzeichnisname <\/td><td>Absoluter Pfad aus Kombination von aktuellem Verzeichnis und relativem Datei-\/Verzeichnispfad<\/td><td>absoluter Datei-\/Verzeichnispfad<\/td><\/tr><tr><td><code>path.normalize()<\/code><\/td><td>normalisierter Datei-\/Verzeichnisname<\/td><td>normalisierter relativer Datei-\/Verzeichnisname<\/td><td>normalisierter absoluter Datei-\/Verzeichnisname<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"zusammenfassung-und-ausblick\">Zusammenfassung und Ausblick<\/h2>\n\n\n\n<p>Dieser Artikel gab einen ausf\u00fchrlichen \u00dcberblick dar\u00fcber, wie man mit Hilfe der Klassen <code>File<\/code>, <code>Path<\/code> und <code>Paths<\/code> Datei- und Verzeichnispfade betriebssystemunabh\u00e4ngig  konstruiert. <\/p>\n\n\n\n<p>Meine Empfehlung ist es ab Java 7 ausschlie\u00dflich die NIO.2-Klassen <code>Path<\/code> und <code>Paths<\/code> zu verwenden, bzw. ab Java 11 nur noch <code>Path<\/code>. Wenn du f\u00fcr eine bestimmte Datei-Operation ein <code>File<\/code>-Objekt ben\u00f6tigst, kannst du dir jederzeit \u00fcber <code>Path.toFile()<\/code> eines erzeugen lassen.<\/p>\n\n\n\n<p>In den folgenden Teilen der Serie wird es um folgende Themen gehen:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><a href=\"\/de\/java\/verzeichnisse-listen-dateien-verschieben-kopieren-loeschen\/#Verzeichnisoperationen\">Verzeichnis-Operationen, wie z. B. das Einlesen der Dateiliste eines Verzeichnisses<\/a><\/li>\n\n\n\n<li><a href=\"\/de\/java\/verzeichnisse-listen-dateien-verschieben-kopieren-loeschen\/#Wie_verschiebt_man_eine_Datei_in_Java\">Kopieren, Verschieben und L\u00f6schen von Dateien<\/a><\/li>\n\n\n\n<li><a href=\"\/de\/java\/verzeichnisse-listen-dateien-verschieben-kopieren-loeschen\/#Eine_temporaere_Datei_erstellen\">Erstellen von tempor\u00e4ren Dateien<\/a><\/li>\n\n\n\n<li><a href=\"\/de\/java\/strukturierte-daten-schreiben-lesen-dataoutputstream-datainputstream\/\">Laden und Schreiben strukturierter Daten mit&nbsp;<code>DataOutputStream<\/code> und&nbsp;<code>DataInputStream<\/code><\/a><\/li>\n<\/ul>\n\n\n\n<p>Im sp\u00e4teren Verlauf kommen wir zu fortgeschrittenen Themen:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Die in Java 1.4 eingef\u00fchrten <a href=\"https:\/\/www.happycoders.eu\/de\/java\/filechannel-memory-mapped-io-locks\/\">NIO-Channels und Buffer<\/a>, um insbesondere das Arbeiten mit gro\u00dfen Dateien zu beschleunigen<\/li>\n\n\n\n<li><a href=\"https:\/\/www.happycoders.eu\/de\/java\/filechannel-memory-mapped-io-locks\/#Memory-mapped_Files_Wie_man_einen_Teil_einer_Datei_in_den_Speicher_mappt\">Memory-mapped I\/O<\/a> f\u00fcr rasend schnellen Dateizugriff ohne Streams<\/li>\n\n\n\n<li><a href=\"https:\/\/www.happycoders.eu\/de\/java\/filechannel-memory-mapped-io-locks\/#File_Locking_Sperren_von_Dateibereichen\">File Locking<\/a>, um parallel \u2013 also aus mehreren Threads oder Prozessen \u2013 konfliktfrei auf dieselben Dateien zuzugreifen<\/li>\n<\/ul>\n\n\n\n<p>Hast du Fragen, Anregungen, Verbesserungsvorschl\u00e4ge? Dann freue ich mich \u00fcber einen Kommentar. Kennst du andere, die das Thema interessant finden? Dann freue ich mich, wenn du den Artikel \u00fcber einen der Buttons unten teilst. M\u00f6chtest du informiert werden, wenn der n\u00e4chste Teil erscheint? Dann <a href=\"#\" data-formkit-toggle=\"d8ee997126\">klicke hier<\/a>, um dich f\u00fcr den HappyCoders-Newsletter anzumelden.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Dieser dritte Teil der Artikelserie zeigt, wie du die Klassen File, Path und Paths \u2013 unabh\u00e4ngig vom Betriebssystem \u2013 zur Konstruktion von Datei- und Verzeichnispfaden verwenden kannst.<\/p>\n","protected":false},"author":1,"featured_media":34414,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_seopress_robots_primary_cat":"none","_seopress_titles_title":"","_seopress_titles_desc":"Was ist der Unterschied zwischen Dateiname, Verzeichnisname und Pfad? Wie verwendet man die Klassen File, Path und Paths in Java?","_seopress_robots_index":"","_uag_custom_page_level_css":"","_wp_convertkit_post_meta":{"form":"-1","landing_page":"","tag":"0","restrict_content":"0"},"_metis_text_type":"standard","_metis_text_length":30806,"_post_count":0,"footnotes":""},"categories":[64],"tags":[166],"class_list":["post-8554","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-java-dateien"],"uagb_featured_image_src":{"full":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java.jpg",1770,986,false],"thumbnail":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java.jpg",150,84,false],"medium":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java.jpg",300,167,false],"medium_large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java.jpg",768,428,false],"large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java.jpg",1024,570,false],"feature_thumb_224":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java-224x125.jpg",224,125,true],"feature_thumb_336":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java-336x187.jpg",336,187,true],"feature_thumb_504":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java-504x281.jpg",504,281,true],"feature_thumb_672":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java-672x374.jpg",672,374,true],"half_400":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java-400x223.jpg",400,223,true],"half_600":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java-600x334.jpg",600,334,true],"full_800":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java-800x446.jpg",800,446,true],"full_944":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java-944x526.jpg",944,526,true],"full_1200":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java-1200x668.jpg",1200,668,true],"wide_1180":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java-1180x490.jpg",1180,490,true],"wide_1770":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java-1770x735.jpg",1770,735,true],"1536x1536":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java.jpg",1536,856,false],"2048x2048":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2020\/01\/directory-and-file-names-java.jpg",1770,986,false]},"uagb_author_info":{"display_name":"Sven Woltmann","author_link":"https:\/\/www.happycoders.eu\/de\/author\/sven\/"},"uagb_comment_info":0,"uagb_excerpt":"Dieser dritte Teil der Artikelserie zeigt, wie du die Klassen File, Path und Paths \u2013 unabh\u00e4ngig vom Betriebssystem \u2013 zur Konstruktion von Datei- und Verzeichnispfaden verwenden kannst.","public_identification_id":"42e5c8896e2c429e96f761ee40638acc","private_identification_id":"b9e1472b6e504ff1a08eeea403eb0402","_links":{"self":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/8554","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/comments?post=8554"}],"version-history":[{"count":10,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/8554\/revisions"}],"predecessor-version":[{"id":41927,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/8554\/revisions\/41927"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media\/34414"}],"wp:attachment":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media?parent=8554"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/categories?post=8554"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/tags?post=8554"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}