Mit der Version 7 wurde in Java die Art und Weise, Dateien zu verwalten und Dateiinhalte zu bearbeiten, von Grund auf neu implementiert. Zwar existiert auch weiterhin die altbekannte Klasse java.io.File, zusätzlich gibt es nun jedoch im Package java.nio.file ein komplett neues und von java.io.File losgelöstes API zum Zugriff auf das Dateisystem.
Um Ihr Projekt für die Verwendung von File-APIs einzurichten, müssen Sie lediglich diesen Import durchführen:
import java.nio.file.*;Da die Codebeispiele in diesem Artikel wahrscheinlich in unterschiedlichen Umgebungen ausgeführt werden, sollten wir uns das Home-Verzeichnis des Benutzers ansehen, das für alle Betriebssysteme gültig ist
Um das Home-Verzeichnis des Benutzers betriebssystemunabhängig in Java zu erhalten, können Sie die folgende Methode verwenden:
string homeDirectory = System.getProperty("user.home");
Diese Methode liefert das Home-Verzeichnis des aktuellen Benutzers und funktioniert auf verschiedenen Betriebssystemen wie Windows, Linux und macOS.
Beispiele für die Rückgabewerte auf verschiedenen Systemen:
- Windows: C:\Users\Benutzername
- Linux: /home/Benutzername
- macOS: /Users/Benutzername
Diese Methode ist zuverlässig und wird in der Java-Entwicklung häufig verwendet, um auf das Home-Verzeichnis des Benutzers zuzugreifen, unabhängig vom zugrunde liegenden Betriebssyste
private static String HOME = System.getProperty("user.home");
Die Klasse „Files“ ist einer der primären Einstiegspunkte des Pakets „java.nio.file“. Diese Klasse bietet eine umfangreiche Reihe von APIs zum Lesen, Schreiben und Bearbeiten von Dateien und Verzeichnissen. Die Methoden der Klasse „Files“ arbeiten mit Instanzen von Path-Objekten.
Das Java NIO-Paket bietet eine weitere Utility-API namens Files, die grundsätzlich zum Bearbeiten von Dateien und Verzeichnissen mithilfe ihrer statischen Methoden verwendet wird, die hauptsächlich mit Path-Objekten funktionieren.
Wie im Path-Tutorial erwähnt, wurde die Path-Schnittstelle im Java NIO-Paket während der Java 7-Version im File-Paket eingeführt. Dieses Tutorial ist also für dasselbe File-Paket.
Diese Klasse besteht ausschließlich aus statischen Methoden, die mit Dateien, Verzeichnissen oder anderen Dateitypen arbeiten. In den meisten Fällen delegieren die hier definierten Methoden die Ausführung der Dateioperationen an den zugehörigen Dateisystemanbieter.
In der Files-Klasse sind viele Methoden definiert, die auch aus Java-Dokumenten gelesen werden können. In diesem Tutorial haben wir versucht, einige der wichtigsten Methoden unter allen Methoden der Java NIO Files-Klasse abzudecken.
Wichtige Methoden der Files-Klasse.
Im Folgenden sind die wichtigen Methoden aufgeführt, die in der Java NIO Files-Klasse definiert sind.
Dateien erstellen
Die Dateisystem-API bietet einzeilige Operationen zum Erstellen von Dateien. Um eine normale Datei zu erstellen, verwenden wir die API createFile und übergeben ihr ein Path-Objekt, das die zu erstellende Datei darstellt. Alle Namenselemente im Pfad müssen vorhanden sein, abgesehen vom Dateinamen, sonst erhalten wir eine IOException:
@Test
public void givenFilePath_whenCreatesNewFile_thenCorrect() {
String fileName = "myfile_" + UUID.randomUUID().toString() + ".txt";
Path p = Paths.get(HOME + "/" + fileName);
assertFalse(Files.exists(p));
Files.createFile(p);
assertTrue(Files.exists(p));
}Im obigen Test stellen wir bei der ersten Überprüfung des Pfads fest, dass er nicht existiert. Nach der Operation „createFile“ stellt sich jedoch heraus, dass er existiert.
Um ein Verzeichnis zu erstellen, verwenden wir die API „createDirectory“:
@Test
public void givenDirPath_whenCreatesNewDir_thenCorrect() {
String dirName = "myDir_" + UUID.randomUUID().toString();
Path p = Paths.get(HOME + "/" + dirName);
assertFalse(Files.exists(p));
Files.createDirectory(p);
assertTrue(Files.exists(p));
assertFalse(Files.isRegularFile(p));
assertTrue(Files.isDirectory(p));
}createFile(Path filePath, FileAttribute attrs) – Die Klasse „Files“ bietet diese Methode, um eine Datei mit dem angegebenen Pfad zu erstellen.
package com.java.nio;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class CreateFile {
public static void main(String[] args) {
//initialize Path object
Path path = Paths.get("D:file.txt");
//create file
try {
Path createdFilePath = Files.createFile(path);
System.out.println("Created a file at : "+createdFilePath);
}
catch (IOException e) {
e.printStackTrace();
}
}
}
copy(InputStream in, Path target, CopyOption options) − Diese Methode wird verwendet, um alle Bytes vom angegebenen Eingabestream in die angegebene Zieldatei zu kopieren und gibt die Anzahl der gelesenen oder geschriebenen Bytes als langen Wert zurück.LinkOption für diesen Parameter mit den folgenden Werten −
COPY_ATTRIBUTES − kopiert Attribute in die neue Datei, z. B. das Attribut „letzte Änderungszeit“.
REPLACE_EXISTING − ersetzt eine vorhandene Datei, falls vorhanden.
NOFOLLOW_LINKS − Wenn eine Datei ein symbolischer Link ist, wird der Link selbst und nicht das Ziel des Links kopiert.
package com.java.nio;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.List;
public class dateien {
public static void main(String[] args) {
Path sourceFile = Paths.get("file.txt");
Path targetFile = Paths.get("fileCopy.txt");
try {
Files.copy(sourceFile, targetFile,
StandardCopyOption.REPLACE_EXISTING);
}
catch (IOException ex) {
System.err.format("I/O Error when copying file");
}
Path wiki_path = Paths.get("fileCopy.txt");
Charset charset = Charset.forName("ISO-8859-1");
try {
List<String> lines = Files.readAllLines(wiki_path, charset);
for (String line : lines) {
System.out.println(line);
}
}
catch (IOException e) {
System.out.println(e);
}
}
}createDirectories(Path dir, FileAttribute…attrs) − Diese Methode wird verwendet, um Verzeichnisse unter Verwendung des angegebenen Pfads zu erstellen, indem alle nicht vorhandenen übergeordneten Verzeichnisse erstellt werden.
delete(Path path) − Diese Methode wird verwendet, um die Datei aus dem angegebenen Pfad zu löschen. Sie löst NoSuchFileException aus, wenn die Datei unter dem angegebenen Pfad nicht vorhanden ist oder wenn die Datei ein Verzeichnis ist und dieses möglicherweise nicht leer ist und nicht gelöscht werden kann.
Überprüfen einer Datei oder eines Verzeichnisses exists(Path path) − Diese Methode wird verwendet, um zu prüfen, ob die Datei unter dem angegebenen Pfad vorhanden ist. Wenn die Datei vorhanden ist, wird „true“ zurückgegeben, andernfalls „false“.
Wir können eine Path-Instanz haben, die eine Datei oder ein Verzeichnis im Dateisystem darstellt. Ob die Datei oder das Verzeichnis, auf das sie verweist, existiert oder nicht, zugänglich ist oder nicht, kann durch eine Dateioperation bestätigt werden. Der Einfachheit halber beziehen wir uns, wenn wir den Begriff Datei verwenden, sowohl auf Dateien als auch auf Verzeichnisse, sofern nicht ausdrücklich etwas anderes angegeben ist. Um zu überprüfen, ob eine Datei existiert, verwenden wir die exists-API:
@Test
public void givenExistentPath_whenConfirmsFileExists_thenCorrect() {
Path p = Paths.get(HOME);
assertTrue(Files.exists(p));
}Um zu überprüfen, ob eine Datei nicht existiert, verwenden wir die API notExists:
@Test
public void givenNonexistentPath_whenConfirmsFileNotExists_thenCorrect() {
Path p = Paths.get(HOME + "/inexistent_file.txt");
assertTrue(Files.notExists(p));
}readAllBytes(Path path) − Diese Methode wird verwendet, um alle Bytes aus der Datei unter dem angegebenen Pfad zu lesen und das Byte-Array mit den aus der Datei gelesenen Bytes zurückzugeben.
Es gibt auch statische Methoden, um Dateiberechtigungen zu prüfen. Um zu prüfen, ob eine Datei lesbar ist, verwenden wir die API isReadable:
@Test
public void givenExistentDirPath_whenConfirmsReadable_thenCorrect() {
Path p = Paths.get(HOME);
assertTrue(Files.isReadable(p));
}Um zu prüfen, ob es beschreibbar ist, verwenden wir die isWritable-API:
@Test
public void givenExistentDirPath_whenConfirmsWritable_thenCorrect() {
Path p = Paths.get(HOME);
assertTrue(Files.isWritable(p));
}Um zu prüfen, ob es ausführbar ist, verwenden wir:
@Test
public void givenExistentDirPath_whenConfirmsExecutable_thenCorrect() {
Path p = Paths.get(HOME);
assertTrue(Files.isExecutable(p));
}Dateien erstellen Die Dateisystem-API bietet einzeilige Operationen zum Erstellen von Dateien. Um eine normale Datei zu erstellen, verwenden wir die API createFile und übergeben ihr ein Path-Objekt, das die zu erstellende Datei darstellt. freestar Alle Namenselemente im Pfad müssen vorhanden sein, abgesehen vom Dateinamen, sonst erhalten wir eine IOException:
Temporäre Dateien erstellen
Viele Anwendungen erstellen während ihrer Ausführung eine Spur temporärer Dateien im Dateisystem. Daher verfügen die meisten Dateisysteme über ein dediziertes Verzeichnis zum Speichern der von solchen Anwendungen generierten temporären Dateien. Die neue Dateisystem-API bietet zu diesem Zweck spezielle Operationen. Die API createTempFile führt diese Operation aus. Sie benötigt ein Pfadobjekt, ein Dateipräfix und ein Dateisuffix:
@Test
public void givenFilePath_whenCreatesTempFile_thenCorrect() {
String prefix = "log_";
String suffix = ".txt";
Path p = Paths.get(HOME + "/");
Files.createTempFile(p, prefix, suffix);
assertTrue(Files.exists(p));
}Der obige Test erstellt eine temporäre Datei im HOME-Verzeichnis, wobei die angegebenen Präfix- und Suffixzeichenfolgen vorangestellt bzw. angehängt werden. Wir erhalten einen Dateinamen wie log_8821081429012075286.txt. Die lange numerische Zeichenfolge wird vom System generiert. Wenn wir jedoch kein Präfix und kein Suffix angeben, enthält der Dateiname nur die lange numerische Zeichenfolge und eine Standarderweiterung .tmp:
@Test
public void givenPath_whenCreatesTempFileWithDefaults_thenCorrect() {
Path p = Paths.get(HOME + "/");
Files.createTempFile(p, null, null);
assertTrue(Files.exists(p));
}Der obige Vorgang erstellt eine Datei mit einem Namen wie 8600179353689423985.tmp. Wenn wir weder Pfad, Präfix noch Suffix angeben, verwendet der Vorgang durchgehend Standardeinstellungen. Der Standardspeicherort der erstellten Datei ist das vom Dateisystem bereitgestellte temporäre Dateiverzeichnis:
@Test
public void givenNoFilePath_whenCreatesTempFileInTempDir_thenCorrect() {
Path p = Files.createTempFile(null, null);
assertTrue(Files.exists(p));
}Unter Windows ist dies standardmäßig etwa C:\Benutzer\Benutzer\AppData\Local\Temp\6100927974988978748.tmp. Alle oben genannten Vorgänge können angepasst werden, um Verzeichnisse statt normaler Dateien zu erstellen, indem Sie createTempDirectory anstelle von createTempFile verwenden.
Löschen einer Datei
Um eine Datei zu löschen, verwenden wir die Lösch-API. Der Übersichtlichkeit halber stellt der folgende Test zunächst sicher, dass die Datei noch nicht existiert, erstellt sie dann und bestätigt, dass sie jetzt existiert, und löscht sie schließlich und bestätigt, dass sie nicht mehr existiert:
@Test
public void givenPath_whenDeletes_thenCorrect() {
Path p = Paths.get(HOME + "/fileToDelete.txt");
assertFalse(Files.exists(p));
Files.createFile(p);
assertTrue(Files.exists(p));
Files.delete(p);
assertFalse(Files.exists(p));
}Wenn eine Datei jedoch nicht im Dateisystem vorhanden ist, schlägt der Löschvorgang mit einer IOException fehl:
Fazit In diesem Artikel haben wir etwas über die Datei-APIs in der neuen Dateisystem-API (NIO2) gelernt, die als Teil von Java 7 ausgeliefert wurde, und die meisten wichtigen Dateioperationen in Aktion gesehen.