MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java NIO的文件系统访问与管理

2023-09-032.2k 阅读

Java NIO 简介

Java NIO（New I/O）是从 Java 1.4 开始引入的一套新的 I/O 类库，旨在提供更高效、更灵活的 I/O 操作。与传统的 Java I/O 基于流（Stream）的方式不同，NIO 采用了基于缓冲区（Buffer）和通道（Channel）的方式进行数据传输，这使得它在处理高并发和大规模数据时表现更为出色。

NIO 的核心组件包括缓冲区（Buffer）、通道（Channel）、选择器（Selector）等。缓冲区用于存储数据，通道则是数据传输的管道，而选择器则用于实现多路复用 I/O，使得一个线程可以处理多个通道的 I/O 操作。这种设计理念使得 NIO 在处理网络编程和文件系统访问等方面都具有显著的优势。

Java NIO 的文件系统访问与管理

在 Java NIO 中，对文件系统的访问和管理主要通过 java.nio.file 包下的类和接口来实现。这个包提供了一套丰富的 API，用于处理文件、目录、符号链接等文件系统相关的操作。

Path 接口

Path 接口是 Java NIO 文件系统 API 的核心，它代表了文件系统中的路径。一个 Path 可以表示一个文件或目录的位置，并且可以进行各种路径相关的操作，如解析、规范化、相对路径转换等。

以下是创建 Path 对象的示例代码：

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

public class PathExample {
    public static void main(String[] args) {
        // 通过 Paths.get() 方法创建 Path 对象
        Path path = Paths.get("C:/example/directory/file.txt");
        System.out.println("Path: " + path);
    }
}

在上述代码中，Paths.get() 方法接受一个字符串参数，表示文件或目录的路径。该方法返回一个 Path 对象，我们可以使用这个对象进行后续的操作。

Path 接口提供了许多有用的方法，例如：

  • getFileName()：返回路径中的文件名部分。
  • getParent()：返回路径的父目录部分。
  • getRoot()：返回路径的根部分。
  • normalize()：规范化路径，去除冗余的部分，如 .. 和 .。
  • toAbsolutePath()：返回路径的绝对路径。

以下是这些方法的使用示例：

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

public class PathMethodsExample {
    public static void main(String[] args) {
        Path path = Paths.get("C:/example/directory/file.txt");

        System.out.println("FileName: " + path.getFileName());
        System.out.println("Parent: " + path.getParent());
        System.out.println("Root: " + path.getRoot());

        Path relativePath = Paths.get("subdirectory/../file.txt");
        Path normalizedPath = relativePath.normalize();
        System.out.println("Normalized Path: " + normalizedPath);

        Path absolutePath = relativePath.toAbsolutePath();
        System.out.println("Absolute Path: " + absolutePath);
    }
}

Files 类

Files 类是 Java NIO 文件系统 API 中用于执行文件操作的核心类。它提供了大量的静态方法，用于创建、删除、复制、移动文件和目录，以及读取和写入文件内容等操作。

  1. 文件创建
    • createFile(Path path)：创建一个新的空文件。如果文件已经存在，则抛出 FileAlreadyExistsException 异常。
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class CreateFileExample {
    public static void main(String[] args) {
        Path filePath = Paths.get("C:/example/file.txt");
        try {
            Files.createFile(filePath);
            System.out.println("File created successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
    • createDirectories(Path dir)：创建一个目录及其所有必要的父目录。如果目录已经存在，则不会抛出异常。
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class CreateDirectoriesExample {
    public static void main(String[] args) {
        Path dirPath = Paths.get("C:/example/new/directory");
        try {
            Files.createDirectories(dirPath);
            System.out.println("Directories created successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  2. 文件删除
    • delete(Path path)：删除指定的文件或目录。如果路径指向一个目录，则该目录必须为空才能删除，否则抛出 DirectoryNotEmptyException 异常。如果文件或目录不存在，则抛出 NoSuchFileException 异常。
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class DeleteFileExample {
    public static void main(String[] args) {
        Path filePath = Paths.get("C:/example/file.txt");
        try {
            Files.delete(filePath);
            System.out.println("File deleted successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
    • deleteIfExists(Path path)：如果指定的文件或目录存在，则删除它。如果删除成功，则返回 true；如果文件或目录不存在，则返回 false。
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class DeleteIfExistsExample {
    public static void main(String[] args) {
        Path filePath = Paths.get("C:/example/file.txt");
        try {
            boolean deleted = Files.deleteIfExists(filePath);
            if (deleted) {
                System.out.println("File deleted successfully.");
            } else {
                System.out.println("File does not exist.");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  3. 文件复制与移动
    • copy(Path source, Path target)：将源文件复制到目标位置。如果目标文件已经存在，则抛出 FileAlreadyExistsException 异常。
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class CopyFileExample {
    public static void main(String[] args) {
        Path sourcePath = Paths.get("C:/example/source.txt");
        Path targetPath = Paths.get("C:/example/destination.txt");
        try {
            Files.copy(sourcePath, targetPath);
            System.out.println("File copied successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
    • move(Path source, Path target)：将源文件移动到目标位置。如果目标文件已经存在，则默认情况下会覆盖它。可以通过传递 StandardCopyOption 枚举值来控制移动行为，例如 REPLACE_EXISTING 表示替换已存在的文件，ATOMIC_MOVE 表示原子性移动（确保移动操作要么完全成功，要么完全失败）。
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.io.IOException;

public class MoveFileExample {
    public static void main(String[] args) {
        Path sourcePath = Paths.get("C:/example/source.txt");
        Path targetPath = Paths.get("C:/example/newlocation/source.txt");
        try {
            Files.move(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("File moved successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  4. 文件读写
    • readAllBytes(Path path)：读取指定文件的所有字节，并返回一个字节数组。
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class ReadAllBytesExample {
    public static void main(String[] args) {
        Path filePath = Paths.get("C:/example/file.txt");
        try {
            byte[] bytes = Files.readAllBytes(filePath);
            System.out.println("File content: " + new String(bytes));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
    • write(Path path, byte[] bytes)：将字节数组写入指定的文件。如果文件不存在，则会创建一个新文件；如果文件已存在，则会覆盖原有内容。
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class WriteFileExample {
    public static void main(String[] args) {
        Path filePath = Paths.get("C:/example/file.txt");
        String content = "This is some sample content.";
        try {
            Files.write(filePath, content.getBytes());
            System.out.println("Content written to file successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
    • lines(Path path)：读取指定文件的所有行，并返回一个 Stream<String>，可以方便地进行流处理。
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;
import java.util.stream.Stream;

public class ReadLinesExample {
    public static void main(String[] args) {
        Path filePath = Paths.get("C:/example/file.txt");
        try (Stream<String> lines = Files.lines(filePath)) {
            lines.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件属性

Java NIO 的文件系统 API 允许我们获取和设置文件的各种属性，例如文件大小、创建时间、修改时间等。不同类型的文件系统可能支持不同的属性，因此需要使用不同的属性视图来访问这些属性。

  1. 基本属性视图（BasicFileAttributes）
    • Files.readAttributes(Path path, Class<A> type)：读取指定路径的文件属性，返回一个指定类型的属性视图。
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.BasicFileAttributes;
import java.io.IOException;

public class BasicFileAttributesExample {
    public static void main(String[] args) {
        Path filePath = Paths.get("C:/example/file.txt");
        try {
            BasicFileAttributes attrs = Files.readAttributes(filePath, BasicFileAttributes.class);
            System.out.println("Creation Time: " + attrs.creationTime());
            System.out.println("Last Modified Time: " + attrs.lastModifiedTime());
            System.out.println("File Size: " + attrs.size());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  2. POSIX 属性视图（PosixFileAttributes） POSIX 文件属性视图用于访问 POSIX 风格的文件属性，如所有者、组、权限等。只有在支持 POSIX 标准的文件系统上才能使用此视图。 
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.PosixFileAttributes;
import java.io.IOException;

public class PosixFileAttributesExample {
    public static void main(String[] args) {
        Path filePath = Paths.get("C:/example/file.txt");
        try {
            PosixFileAttributes attrs = Files.readAttributes(filePath, PosixFileAttributes.class);
            System.out.println("Owner: " + attrs.owner());
            System.out.println("Group: " + attrs.group());
            System.out.println("Permissions: " + attrs.permissions());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  3. 设置文件属性
    • 可以通过 Files.setAttribute(Path path, String attribute, Object value) 方法来设置文件属性。例如，设置文件的最后修改时间：
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.FileTime;
import java.io.IOException;

public class SetFileAttributeExample {
    public static void main(String[] args) {
        Path filePath = Paths.get("C:/example/file.txt");
        try {
            FileTime newTime = FileTime.fromMillis(System.currentTimeMillis());
            Files.setAttribute(filePath, "basic:lastModifiedTime", newTime);
            System.out.println("Last Modified Time set successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

符号链接与硬链接

  1. 符号链接（Symbolic Link） 符号链接是一种特殊的文件，它指向另一个文件或目录。在 Java NIO 中，可以使用 Files.createSymbolicLink(Path link, Path target) 方法来创建符号链接。 
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class CreateSymbolicLinkExample {
    public static void main(String[] args) {
        Path targetPath = Paths.get("C:/example/target.txt");
        Path linkPath = Paths.get("C:/example/link.txt");
        try {
            Files.createSymbolicLink(linkPath, targetPath);
            System.out.println("Symbolic link created successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
    要判断一个路径是否是符号链接，可以使用 Files.isSymbolicLink(Path path) 方法： 
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class IsSymbolicLinkExample {
    public static void main(String[] args) {
        Path linkPath = Paths.get("C:/example/link.txt");
        try {
            boolean isSymbolicLink = Files.isSymbolicLink(linkPath);
            if (isSymbolicLink) {
                System.out.println("It is a symbolic link.");
            } else {
                System.out.println("It is not a symbolic link.");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  2. 硬链接（Hard Link） 硬链接是文件的另一个名称，它与原文件共享相同的 inode（文件索引节点）。在 Java NIO 中，可以使用 Files.createLink(Path link, Path existing) 方法来创建硬链接。需要注意的是，并非所有的文件系统都支持硬链接，并且硬链接只能在同一文件系统内创建。 
    import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class CreateHardLinkExample {
    public static void main(String[] args) {
        Path existingPath = Paths.get("C:/example/existing.txt");
        Path linkPath = Paths.get("C:/example/hardlink.txt");
        try {
            Files.createLink(linkPath, existingPath);
            System.out.println("Hard link created successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

遍历文件树

Java NIO 提供了方便的方法来遍历文件树，即递归地访问目录及其子目录中的所有文件和目录。可以使用 Files.walkFileTree(Path start, FileVisitor<? super Path> visitor) 方法来实现。

FileVisitor 是一个接口，定义了在遍历文件树过程中对每个文件和目录进行操作的方法。具体包括：

  • preVisitDirectory(Path dir, BasicFileAttributes attrs)：在访问目录之前调用。
  • visitFile(Path file, BasicFileAttributes attrs)：在访问文件时调用。
  • visitFileFailed(Path file, IOException exc)：在访问文件失败时调用。
  • postVisitDirectory(Path dir, IOException exc)：在访问目录及其所有子项之后调用。

以下是一个简单的文件树遍历示例，用于打印出指定目录下的所有文件和目录：

import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.io.IOException;

public class FileTreeTraversalExample {
    public static void main(String[] args) {
        Path startPath = Paths.get("C:/example");
        try {
            Files.walkFileTree(startPath, new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                    System.out.println("Directory: " + dir);
                    return FileVisitResult.CONTINUE;
                }

                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                    System.out.println("File: " + file);
                    return FileVisitResult.CONTINUE;
                }

                @Override
                public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
                    System.out.println("Failed to visit file: " + file);
                    return FileVisitResult.CONTINUE;
                }

                @Override
                public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
                    if (exc != null) {
                        System.out.println("Failed to visit directory: " + dir);
                    }
                    return FileVisitResult.CONTINUE;
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，SimpleFileVisitor 是 FileVisitor 的一个简单实现类，我们通过重写其中的方法来定义在遍历文件树过程中的具体操作。FileVisitResult 枚举值用于控制遍历的流程，例如 CONTINUE 表示继续遍历，TERMINATE 表示终止遍历。

总结

通过 Java NIO 的 java.nio.file 包，我们可以方便地进行文件系统的访问和管理操作。Path 接口提供了对文件路径的表示和操作，Files 类提供了丰富的文件和目录操作方法，文件属性视图允许我们获取和设置文件的各种属性，符号链接和硬链接的操作增加了文件系统操作的灵活性，而文件树遍历功能则方便我们对整个目录结构进行递归处理。

在实际开发中，合理运用这些功能可以提高文件系统操作的效率和灵活性，无论是处理简单的文件读写，还是复杂的文件管理任务，Java NIO 的文件系统 API 都能提供强大的支持。同时，需要注意不同文件系统对某些功能的支持差异，以确保代码的可移植性和稳定性。