java 文件的操作Path、Paths、Files詳解
更新時間：2024年10月15日 09:36:27 作者：小程xy
Java NIO（New I/O）是Java 7中引入的一項重要特性,旨在提供一種更加靈活和高效的文件處理方式,NIO.2主要通過Path、Paths和Files三個核心組件來實(shí)現(xiàn)對文件和目錄的操作,本文給大家介紹java 文件的操作Path、Paths、Files的相關(guān)知識,感興趣的朋友一起看看吧
Path、Paths 和 Files 是 Java NIO（New I/O）文件處理系統(tǒng)中的核心組件，它們提供了比傳統(tǒng) java.io.File 更加靈活和高效的文件操作方式。
1. 概述
隨著 Java 7 引入 NIO.2（即 Java New I/O 2），文件處理得到了顯著改進(jìn)。Path、Paths 和 Files 是 NIO.2 中用于文件和目錄操作的三個關(guān)鍵組件：
Path：表示文件系統(tǒng)中的路徑，類似于傳統(tǒng)的java.io.File，但更加靈活和功能豐富。Paths：一個工具類，提供靜態(tài)方法用于創(chuàng)建Path實(shí)例。Files：一個實(shí)用工具類，提供了大量靜態(tài)方法用于執(zhí)行文件和目錄的各種操作，如創(chuàng)建、刪除、復(fù)制、移動、讀取和寫入等。
相比傳統(tǒng)的 File 類，NIO.2 提供了更好的錯誤處理、更豐富的功能以及對不同文件系統(tǒng)的支持。
2. Path 接口
概述
Path 是一個接口，位于 java.nio.file 包中，用于表示文件系統(tǒng)中的路徑。它提供了一種平臺無關(guān)的方式來表示文件和目錄的路徑，并支持豐富的路徑操作。
主要功能和方法
以下是 Path 接口的一些關(guān)鍵方法和功能：
路徑創(chuàng)建與解析
Path resolve(String other)：將給定的路徑字符串解析為當(dāng)前路徑的子路徑。Path resolve(Path other)：將給定的Path解析為當(dāng)前路徑的子路徑。Path relativize(Path other)：計算從當(dāng)前路徑到給定路徑的相對路徑。
路徑信息
String getFileName()：返回路徑中的文件名部分。Path getParent()：返回路徑的父路徑。Path getRoot()：返回路徑的根組件。int getNameCount()：返回路徑中的名稱元素數(shù)。Path getName(int index)：返回指定索引的名稱元素。
路徑轉(zhuǎn)換
Path toAbsolutePath()：將相對路徑轉(zhuǎn)換為絕對路徑。Path normalize()：規(guī)范化路徑，去除冗余的名稱元素，如"."和".."。
路徑比較
boolean startsWith(String other)：判斷路徑是否以給定的路徑字符串開頭。boolean endsWith(String other)：判斷路徑是否以給定的路徑字符串結(jié)尾。boolean equals(Object other)：判斷兩個路徑是否相等。
其他方法
Iterator<Path> iterator()：返回一個迭代器，用于遍歷路徑中的名稱元素。String toString()：返回路徑的字符串表示。String toAbsolutePath().toString()：返回絕對路徑的字符串表示。
示例代碼
import java.nio.file.Path;
import java.nio.file.Paths;
public class PathExample {
public static void main(String[] args) {
// 創(chuàng)建 Path 實(shí)例
Path path = Paths.get("src", "main", "java", "Example.java");
// 獲取文件名
System.out.println("文件名: " + path.getFileName());
// 獲取父路徑
System.out.println("父路徑: " + path.getParent());
// 獲取根路徑
System.out.println("根路徑: " + path.getRoot());
// 規(guī)范化路徑
Path normalizedPath = path.normalize();
System.out.println("規(guī)范化路徑: " + normalizedPath);
// 轉(zhuǎn)換為絕對路徑
Path absolutePath = path.toAbsolutePath();
System.out.println("絕對路徑: " + absolutePath);
// 解析子路徑
Path resolvedPath = path.resolve("subdir/File.txt");
System.out.println("解析后的路徑: " + resolvedPath);
// 計算相對路徑
Path basePath = Paths.get("src/main");
Path relativePath = basePath.relativize(path);
System.out.println("相對路徑: " + relativePath);
// 遍歷路徑中的元素
System.out.println("路徑元素:");
for (Path element : path) {
System.out.println(element);
}
}
}輸出示例：
文件名: Example.java
父路徑: src/main/java
根路徑: null
規(guī)范化路徑: src/main/java/Example.java
絕對路徑: /Users/username/project/src/main/java/Example.java
解析后的路徑: src/main/java/Example.java/subdir/File.txt
相對路徑: java/Example.java
路徑元素:
src
main
java
Example.java
3. Paths 類
概述
Paths 是一個最終類，位于 java.nio.file 包中，提供了靜態(tài)方法用于創(chuàng)建 Path 實(shí)例。它簡化了 Path 對象的創(chuàng)建過程，使代碼更加簡潔和易讀。
創(chuàng)建 Path 實(shí)例
import java.nio.file.Path;
import java.nio.file.Paths;
import java.net.URI;
public class PathsExample {
public static void main(String[] args) {
// 使用多個字符串片段創(chuàng)建路徑
Path path1 = Paths.get("C:", "Users", "Public", "Documents");
System.out.println("路徑1: " + path1);
// 使用單個字符串創(chuàng)建路徑
Path path2 = Paths.get("/home/user/docs");
System.out.println("路徑2: " + path2);
// 使用相對路徑創(chuàng)建路徑
Path path3 = Paths.get("src/main/java/Example.java");
System.out.println("路徑3: " + path3);
// 組合路徑片段
Path basePath = Paths.get("/home/user");
Path combinedPath = basePath.resolve("downloads/music");
System.out.println("組合后的路徑: " + combinedPath);
}
}輸出示例：
路徑1: C:\Users\Public\Documents
路徑2: /home/user/docs
路徑3: src/main/java/Example.java
組合后的路徑: /home/user/downloads/music
注意事項
Paths.get(...)方法會根據(jù)操作系統(tǒng)自動處理路徑分隔符，無需手動指定。例如，在 Windows 上會使用\，在 Unix/Linux 上會使用/。
4. Files 類
概述
Files 是一個最終類，位于 java.nio.file 包中，提供了大量的靜態(tài)方法用于執(zhí)行文件和目錄的各種操作。它與 Path 接口緊密集成，提供了比 java.io.File 更加豐富和高效的功能。
主要功能和方法
Files 類的方法可以大致分為以下幾類：
- 文件和目錄的創(chuàng)建
- 文件和目錄的刪除
- 文件和目錄的復(fù)制與移動
- 文件內(nèi)容的讀取與寫入
- 文件屬性的獲取與修改
- 目錄的遍歷和查找
1. 文件和目錄的創(chuàng)建
static Path createFile(Path path, FileAttribute<?>... attrs)：創(chuàng)建一個新文件。static Path createDirectory(Path dir, FileAttribute<?>... attrs)：創(chuàng)建一個新目錄。static Path createDirectories(Path dir, FileAttribute<?>... attrs)：遞歸地創(chuàng)建目錄，包括不存在的父目錄。
2. 文件和目錄的刪除
static void delete(Path path)：刪除指定的文件或目錄。如果路徑是目錄，則目錄必須為空。static boolean deleteIfExists(Path path)：刪除指定的文件或目錄，如果存在的話。
3. 文件和目錄的復(fù)制與移動
static Path copy(Path source, Path target, CopyOption... options)：復(fù)制文件或目錄。static Path move(Path source, Path target, CopyOption... options)：移動或重命名文件或目錄。
4. 文件內(nèi)容的讀取與寫入
static byte[] readAllBytes(Path path)：讀取文件的所有字節(jié)。static List<String> readAllLines(Path path, Charset cs)：按行讀取文件內(nèi)容。static Path write(Path path, byte[] bytes, OpenOption... options)：將字節(jié)數(shù)組寫入文件。static Path write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption... options)：將行寫入文件。
5. 文件屬性的獲取與修改
static boolean exists(Path path, LinkOption... options)：檢查路徑是否存在。static boolean isDirectory(Path path, LinkOption... options)：判斷路徑是否是目錄。static boolean isRegularFile(Path path, LinkOption... options)：判斷路徑是否是常規(guī)文件。static long size(Path path)：獲取文件的大?。ㄒ宰止?jié)為單位）。static FileTime getLastModifiedTime(Path path, LinkOption... options)：獲取文件的最后修改時間。static Path setLastModifiedTime(Path path, FileTime time)：設(shè)置文件的最后修改時間。
6. 目錄的遍歷和查找
static DirectoryStream<Path> newDirectoryStream(Path dir, DirectoryStream.Filter<? super Path> filter)：打開一個目錄流，遍歷目錄中的文件和子目錄。static Stream<Path> walk(Path start, FileVisitOption... options)：遞歸地遍歷目錄樹。static Stream<Path> list(Path dir)：列出目錄中的內(nèi)容，不進(jìn)行遞歸。
示例代碼
以下是一些常見的 Files 類方法的示例：
創(chuàng)建文件和目錄
import java.nio.file.*;
import java.io.IOException;
public class FilesCreateExample {
public static void main(String[] args) {
Path directory = Paths.get("exampleDir");
Path file = directory.resolve("exampleFile.txt");
try {
// 創(chuàng)建目錄
if (!Files.exists(directory)) {
Files.createDirectory(directory);
System.out.println("目錄已創(chuàng)建: " + directory);
}
// 創(chuàng)建文件
if (!Files.exists(file)) {
Files.createFile(file);
System.out.println("文件已創(chuàng)建: " + file);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}寫入和讀取文件內(nèi)容
import java.nio.file.*;
import java.io.IOException;
import java.util.List;
public class FilesReadWriteExample {
public static void main(String[] args) {
Path file = Paths.get("exampleDir/exampleFile.txt");
// 寫入字節(jié)數(shù)組到文件
String content = "Hello, Java NIO!";
try {
Files.write(file, content.getBytes(), StandardOpenOption.WRITE);
System.out.println("數(shù)據(jù)已寫入文件");
} catch (IOException e) {
e.printStackTrace();
}
// 讀取所有字節(jié)
try {
byte[] data = Files.readAllBytes(file);
System.out.println("文件內(nèi)容 (字節(jié)): " + new String(data));
} catch (IOException e) {
e.printStackTrace();
}
// 按行讀取文件內(nèi)容
try {
List<String> lines = Files.readAllLines(file, StandardOpenOption.READ);
System.out.println("文件內(nèi)容 (按行):");
for (String line : lines) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}復(fù)制和移動文件
import java.nio.file.*;
import java.io.IOException;
public class FilesCopyMoveExample {
public static void main(String[] args) {
Path source = Paths.get("exampleDir/exampleFile.txt");
Path targetCopy = Paths.get("exampleDir/copyOfExampleFile.txt");
Path targetMove = Paths.get("exampleDir/movedExampleFile.txt");
try {
// 復(fù)制文件
Files.copy(source, targetCopy, StandardCopyOption.REPLACE_EXISTING);
System.out.println("文件已復(fù)制到: " + targetCopy);
// 移動文件
Files.move(source, targetMove, StandardCopyOption.REPLACE_EXISTING);
System.out.println("文件已移動到: " + targetMove);
} catch (IOException e) {
e.printStackTrace();
}
}
}刪除文件和目錄
import java.nio.file.*;
import java.io.IOException;
public class FilesDeleteExample {
public static void main(String[] args) {
Path file = Paths.get("exampleDir/movedExampleFile.txt");
Path directory = Paths.get("exampleDir");
try {
// 刪除文件
if (Files.deleteIfExists(file)) {
System.out.println("文件已刪除: " + file);
}
// 刪除目錄（目錄必須為空）
if (Files.deleteIfExists(directory)) {
System.out.println("目錄已刪除: " + directory);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}遍歷目錄內(nèi)容
import java.nio.file.*;
import java.io.IOException;
public class FilesListDirectoryExample {
public static void main(String[] args) {
Path directory = Paths.get("exampleDir");
try (DirectoryStream<Path> stream = Files.newDirectoryStream(directory)) {
System.out.println("目錄中的文件:");
for (Path entry : stream) {
System.out.println(entry.getFileName());
}
} catch (IOException e) {
e.printStackTrace();
}
}
}獲取和設(shè)置文件屬性
import java.nio.file.*;
import java.nio.file.attribute.FileTime;
import java.io.IOException;
public class FilesAttributesExample {
public static void main(String[] args) {
Path file = Paths.get("exampleDir/exampleFile.txt");
try {
// 獲取文件大小
long size = Files.size(file);
System.out.println("文件大小: " + size + " 字節(jié)");
// 獲取最后修改時間
FileTime lastModifiedTime = Files.getLastModifiedTime(file);
System.out.println("最后修改時間: " + lastModifiedTime);
// 設(shè)置最后修改時間為當(dāng)前時間
FileTime newTime = FileTime.fromMillis(System.currentTimeMillis());
Files.setLastModifiedTime(file, newTime);
System.out.println("最后修改時間已更新");
// 檢查文件是否存在
boolean exists = Files.exists(file);
System.out.println("文件存在: " + exists);
// 檢查是否為目錄
boolean isDirectory = Files.isDirectory(file);
System.out.println("是目錄: " + isDirectory);
// 檢查是否為常規(guī)文件
boolean isRegularFile = Files.isRegularFile(file);
System.out.println("是常規(guī)文件: " + isRegularFile);
} catch (IOException e) {
e.printStackTrace();
}
}
}注意事項
- 異常處理：大多數(shù)
Files類的方法都會拋出IOException，因此在使用這些方法時需要適當(dāng)?shù)漠惓Ｌ幚怼?/li> - 原子操作：某些方法（如
Files.move）可以進(jìn)行原子操作，確保文件操作的完整性。 - 性能考慮：對于大文件或大量文件操作，考慮使用流式處理方法（如
Files.newBufferedReader和Files.newBufferedWriter）以提高性能和減少內(nèi)存消耗。
5. Path、Paths 和 Files 的協(xié)同使用
這三個組件通常一起使用，以實(shí)現(xiàn)對文件和目錄的全面操作。以下是一個綜合示例，展示了如何使用 Path、Paths 和 Files 完成常見的文件操作任務(wù)。
綜合示例
import java.nio.file.*;
import java.io.IOException;
import java.util.List;
import java.nio.charset.StandardCharsets;
public class ComprehensiveFileOperations {
public static void main(String[] args) {
Path directory = Paths.get("comprehensiveExampleDir");
Path file = directory.resolve("exampleFile.txt");
Path copyFile = directory.resolve("copyOfExampleFile.txt");
Path movedFile = directory.resolve("movedExampleFile.txt");
try {
// 1. 創(chuàng)建目錄
if (!Files.exists(directory)) {
Files.createDirectory(directory);
System.out.println("目錄已創(chuàng)建: " + directory);
}
// 2. 創(chuàng)建文件
if (!Files.exists(file)) {
Files.createFile(file);
System.out.println("文件已創(chuàng)建: " + file);
}
// 3. 寫入數(shù)據(jù)到文件
String content = "Hello, Comprehensive Java NIO!";
Files.write(file, content.getBytes(StandardCharsets.UTF_8), StandardOpenOption.WRITE);
System.out.println("數(shù)據(jù)已寫入文件: " + file);
// 4. 讀取文件內(nèi)容
List<String> lines = Files.readAllLines(file, StandardCharsets.UTF_8);
System.out.println("文件內(nèi)容:");
for (String line : lines) {
System.out.println(line);
}
// 5. 復(fù)制文件
Files.copy(file, copyFile, StandardCopyOption.REPLACE_EXISTING);
System.out.println("文件已復(fù)制到: " + copyFile);
// 6. 移動文件
Files.move(file, movedFile, StandardCopyOption.REPLACE_EXISTING);
System.out.println("文件已移動到: " + movedFile);
// 7. 獲取文件屬性
long size = Files.size(movedFile);
FileTime lastModifiedTime = Files.getLastModifiedTime(movedFile);
System.out.println("文件大小: " + size + " 字節(jié)");
System.out.println("最后修改時間: " + lastModifiedTime);
// 8. 遍歷目錄中的文件
System.out.println("目錄中的文件:");
try (DirectoryStream<Path> stream = Files.newDirectoryStream(directory)) {
for (Path entry : stream) {
System.out.println(entry.getFileName());
}
}
// 9. 刪除文件和目錄
Files.deleteIfExists(copyFile);
System.out.println("復(fù)制的文件已刪除: " + copyFile);
Files.deleteIfExists(movedFile);
System.out.println("移動的文件已刪除: " + movedFile);
Files.deleteIfExists(directory);
System.out.println("目錄已刪除: " + directory);
} catch (IOException e) {
e.printStackTrace();
}
}
}運(yùn)行結(jié)果示例：
目錄已創(chuàng)建: comprehensiveExampleDir
文件已創(chuàng)建: comprehensiveExampleDir/exampleFile.txt
數(shù)據(jù)已寫入文件: comprehensiveExampleDir/exampleFile.txt
文件內(nèi)容:
Hello, Comprehensive Java NIO!
文件已復(fù)制到: comprehensiveExampleDir/copyOfExampleFile.txt
文件已移動到: comprehensiveExampleDir/movedExampleFile.txt
文件大小: 31 字節(jié)
最后修改時間: 2024-04-27T10:15:30Z
目錄中的文件:
copyOfExampleFile.txt
movedExampleFile.txt
復(fù)制的文件已刪除: comprehensiveExampleDir/copyOfExampleFile.txt
移動的文件已刪除: comprehensiveExampleDir/movedExampleFile.txt
目錄已刪除: comprehensiveExampleDir
解釋
- 創(chuàng)建目錄和文件：使用
Files.createDirectory和Files.createFile方法創(chuàng)建目錄和文件。 - 寫入和讀取文件：使用
Files.write將字符串寫入文件，使用Files.readAllLines讀取文件內(nèi)容。 - 復(fù)制和移動文件：使用
Files.copy復(fù)制文件，使用Files.move移動文件。 - 獲取文件屬性：使用
Files.size和Files.getLastModifiedTime獲取文件的大小和最后修改時間。 - 遍歷目錄：使用
Files.newDirectoryStream遍歷目錄中的文件。 - 刪除文件和目錄：使用
Files.deleteIfExists刪除文件和目錄。
6. 高級功能和最佳實(shí)踐
1. 使用文件過濾器
Files.newDirectoryStream 方法支持使用過濾器來篩選目錄中的文件。例如，僅列出 .txt 文件：
import java.nio.file.*;
import java.io.IOException;
public class FilesFilterExample {
public static void main(String[] args) {
Path directory = Paths.get("exampleDir");
try (DirectoryStream<Path> stream = Files.newDirectoryStream(directory, "*.txt")) {
System.out.println("目錄中的 .txt 文件:");
for (Path entry : stream) {
System.out.println(entry.getFileName());
}
} catch (IOException e) {
e.printStackTrace();
}
}
}2. 使用文件遍歷器
對于復(fù)雜的目錄遍歷，可以使用 Files.walkFileTree 方法結(jié)合 FileVisitor 接口，實(shí)現(xiàn)自定義的遍歷邏輯。例如，查找目錄中所有的 .java 文件：
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.io.IOException;
public class FilesWalkFileTreeExample {
public static void main(String[] args) {
Path startPath = Paths.get("src");
try {
Files.walkFileTree(startPath, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
if (file.toString().endsWith(".java")) {
System.out.println("找到 Java 文件: " + file);
}
return FileVisitResult.CONTINUE;
}
});
} catch (IOException e) {
e.printStackTrace();
}
}
}3. 異步文件操作
雖然 Files 類主要提供同步方法，但結(jié)合 Java NIO 的異步通道（如 AsynchronousFileChannel），可以實(shí)現(xiàn)異步文件操作，提高性能。
import java.nio.file.*;
import java.nio.channels.*;
import java.nio.ByteBuffer;
import java.io.IOException;
import java.util.concurrent.Future;
public class AsynchronousFileExample {
public static void main(String[] args) {
Path file = Paths.get("asyncExample.txt");
try (AsynchronousFileChannel asyncChannel = AsynchronousFileChannel.open(file, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) {
String content = "Asynchronous File Writing in Java NIO.";
ByteBuffer buffer = ByteBuffer.wrap(content.getBytes());
Future<Integer> operation = asyncChannel.write(buffer, 0);
while (!operation.isDone()) {
System.out.println("正在寫入文件...");
Thread.sleep(100);
}
System.out.println("寫入完成，寫入字節(jié)數(shù): " + operation.get());
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}4. 處理文件系統(tǒng)差異
NIO.2 支持不同類型的文件系統(tǒng)（如本地文件系統(tǒng)、ZIP 文件系統(tǒng)等）。可以使用 FileSystem 類和相關(guān)方法來處理不同的文件系統(tǒng)。
import java.nio.file.*;
import java.io.IOException;
public class ZipFileSystemExample {
public static void main(String[] args) {
Path zipPath = Paths.get("example.zip");
try (FileSystem zipFs = FileSystems.newFileSystem(zipPath, null)) {
Path internalPath = zipFs.getPath("/newFile.txt");
Files.write(internalPath, "內(nèi)容寫入 ZIP 文件".getBytes(), StandardOpenOption.CREATE);
System.out.println("文件已寫入 ZIP 文件");
} catch (IOException e) {
e.printStackTrace();
}
}
}5. 錯誤處理和資源管理
- 異常處理：盡量使用具體的異常類型，如
NoSuchFileException、DirectoryNotEmptyException等，以便更精確地處理錯誤。 - 資源管理：使用 try-with-resources 語句自動關(guān)閉流和目錄流，避免資源泄漏。
import java.nio.file.*;
import java.io.IOException;
public class ResourceManagementExample {
public static void main(String[] args) {
Path file = Paths.get("exampleDir/exampleFile.txt");
// 使用 try-with-resources 讀取文件內(nèi)容
try (BufferedReader reader = Files.newBufferedReader(file, StandardCharsets.UTF_8)) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}6. 性能優(yōu)化
- 批量操作：盡量批量讀取或?qū)懭霐?shù)據(jù)，減少 I/O 操作的次數(shù)。
- 緩沖流：使用緩沖流（如
BufferedReader和BufferedWriter）提高讀寫性能。 - 并行處理：對于大規(guī)模文件操作，可以考慮并行處理，如使用多線程或并行流。
7. 總結(jié)
Path、Paths 和 Files 是 Java NIO.2 中處理文件和目錄操作的核心組件，提供了比傳統(tǒng) java.io.File 更加現(xiàn)代化、靈活和高效的功能。以下是它們的主要特點(diǎn)和最佳使用場景：
Path：- 表示文件系統(tǒng)中的路徑，提供豐富的路徑操作方法。
- 不同于
String，提供平臺無關(guān)的路徑處理。
Paths：- 提供靜態(tài)方法
get，簡化Path對象的創(chuàng)建過程。 - 使代碼更加簡潔和易讀。
- 提供靜態(tài)方法
Files：- 提供大量靜態(tài)方法用于執(zhí)行文件和目錄的各種操作，如創(chuàng)建、刪除、復(fù)制、移動、讀取、寫入等。
- 與
Path緊密集成，支持高級文件操作和屬性管理。
最佳實(shí)踐
- 優(yōu)先使用 NIO.2 的類：在新的項目中，優(yōu)先使用
Path、Paths和Files，而非java.io.File，以獲得更好的性能和更多功能。 - 使用 try-with-resources：確保所有的流和資源在使用后被正確關(guān)閉，避免資源泄漏。
- 處理具體異常：盡量捕獲和處理具體的異常類型，以便更好地應(yīng)對不同的錯誤情況。
- 優(yōu)化性能：對于大量或大規(guī)模的文件操作，考慮使用緩沖流、批量操作或并行處理來提高性能。
- 利用文件過濾和遍歷器：使用
DirectoryStream和FileVisitor實(shí)現(xiàn)高效的文件過濾和目錄遍歷。 - 保持路徑的不可變性：
Path對象是不可變的，這有助于線程安全和代碼的健壯性。
通過充分理解和運(yùn)用 Path、Paths 和 Files，可以高效地處理 Java 應(yīng)用中的各種文件和目錄操作任務(wù)，提升代碼的可維護(hù)性和性能。
到此這篇關(guān)于java 文件的操作（Path、Paths、Files） 的文章就介紹到這了,更多相關(guān)java文件操作內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章主要為大家詳細(xì)介紹了Java實(shí)現(xiàn)簡單的日歷界面，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-06-06
filter 就像其本意一樣,可以通過 filter 對 Kotlin list 進(jìn)行過濾,本文重點(diǎn)給大家介紹Kotlin中常見的List使用,感興趣的朋友一起看看吧2023-11-11
這篇文章主要介紹了詳解spring boot應(yīng)用啟動原理分析，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-06-06
Jpa?Specification如何實(shí)現(xiàn)and和or同時使用查詢
這篇文章主要介紹了Jpa?Specification如何實(shí)現(xiàn)and和or同時使用查詢，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-11-11
java?random隨機(jī)數(shù)的用法及常見應(yīng)用場景
這篇文章主要給大家介紹了關(guān)于java?random隨機(jī)數(shù)的用法及常見應(yīng)用場景的相關(guān)資料,Java中的Random類是用來生成偽隨機(jī)數(shù)的工具類,它可以用來生成隨機(jī)的整數(shù)、浮點(diǎn)數(shù)和布爾值,需要的朋友可以參考下2023-11-11
這篇文章主要介紹了tk.mybatis擴(kuò)展通用接口使用詳解,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2019-08-08
這篇文章主要介紹了Java????????HashMap遍歷方法匯總，HashMap?的遍歷方法有很多種，不同的?JDK?版本有不同的寫法，下文關(guān)于其遍歷方法總結(jié)需要的小伙伴可以參考一下2022-05-05
詳解基于MVC的數(shù)據(jù)查詢模塊進(jìn)行模糊查詢
這篇文章主要介紹了Java基于MVC的數(shù)據(jù)查詢模塊進(jìn)行模糊查詢，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-01-01
SpringBoot實(shí)現(xiàn)給屬性賦值的兩種方式
在Spring Boot中,配置文件是用來設(shè)置應(yīng)用程序的各種參數(shù)和操作模式的重要部分,Spring Boot支持兩種主要類型的配置文件：properties文件和YAML 文件,這兩種文件都可以用來定義相同的配置,接下來由小編給大家詳細(xì)的介紹一下這兩種方式2024-07-07
SpringBoot如何統(tǒng)一處理返回結(jié)果和異常情況
這篇文章主要介紹了SpringBoot如何統(tǒng)一處理返回結(jié)果和異常情況問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-05-05