在Java编程中，File类是处理文件和目录路径名的抽象表示形式。提供了大量静态和实例方法，用于创建、删除、查询文件和目录。

File类的定义与构造方法

File类位于java.io包中，表示文件或目录的路径名。提供了多个构造方法来创建File对象。

public File(String pathname)
public File(String parent, String child)
public File(File parent, String child)
public File(URI uri)

示例：

import java.io.File;
public class FileClassExample {
  public static void main(String[] args) {
    // 使用构造方法创建File对象的示例
    File fileFromAbsolutePath = new File("/home/user/documents/example.txt");
    File fileFromRelativePath = new File("documents/example.txt");
    File fileFromParentAndChild = new File("/home/user/documents", "example.txt");
    System.out.println("File created from absolute path: " + fileFromAbsolutePath.getAbsolutePath());
    System.out.println("File created from relative path: " + fileFromRelativePath.getAbsolutePath());
    System.out.println("File created from parent and child paths: " + fileFromParentAndChild.getAbsolutePath());
  }
}

文件的基本操作

判断文件或目录是否存在

if (file.exists()) {
  System.out.println("File exists.");
} else {
  System.out.println("File does not exist.");
}

判断是文件还是目录：

if (file.isFile()) {
  System.out.println("It is a file.");
} else if (file.isDirectory()) {
  System.out.println("It is a directory.");
}

创建文件或目录：

if (file.createNewFile()) {
  System.out.println("File created: " + file.getName());
} else {
  System.out.println("File already exists.");
}

// 创建目录
if (file.mkdir()) {
  System.out.println("Directory created: " + file.getName());
} else {
  System.out.println("Directory already exists or could not be created.");
}

注意，createNewFile()方法仅用于创建文件，如果文件已存在，将返回false。而mkdir()方法用于创建目录，如果目录已存在，也将返回false。

删除文件或目录：

if (file.delete()) {
  System.out.println("File or directory deleted: " + file.getName());
} else {
  System.out.println("File or directory could not be deleted.");
}

需要注意的是，删除目录时，如果目录非空，将不会删除该目录及其内容。如果需要删除非空目录及其内容，需要递归地删除目录中的每个文件和子目录。

获取文件属性

使用File类的实例方法，可以获取与文件或目录相关的各种属性：

示例：

import java.io.File;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
public class FileAttributesExtractor {
  private final File file;
  public FileAttributesExtractor(String filePath) {
    this.file = new File(filePath);
  }
  /**
* 获取文件路径
* @return 路径字符串
*/
  public String getPath() {
    return file.getPath();
  }
  /**
* 获取文件的绝对路径
* @return 绝对路径字符串
*/
  public String getAbsolutePath() {
    return file.getAbsolutePath();
  }
  /**
* 检查文件或目录是否存在
* @return true表示存在，false表示不存在
*/
  public boolean exists() {
    return file.exists();
  }
  /**
* 判断路径是否是一个文件
* @return true表示是文件，false表示不是文件（可能是目录或其他非文件实体）
*/
  public boolean isFile() {
    return file.isFile();
  }
  /**
* 判断路径是否是一个目录
* @return true表示是目录，false表示不是目录
*/
  public boolean isDirectory() {
    return file.isDirectory();
  }
  /**
* 检查当前应用程序是否有读取文件的权限
* @return true表示有读取权限，false表示无读取权限
*/
  public boolean canRead() {
    return file.canRead();
  }
  /**
* 检查当前应用程序是否有写入文件的权限
* @return true表示有写入权限，false表示无写入权限
*/
  public boolean canWrite() {
    return file.canWrite();
  }
  /**
* 获取文件大小（以字节为单位）
* @return 文件大小（字节数）
*/
  public long getSize() {
    return file.length();
  }
  /**
* 获取文件或目录最后修改时间
* @return 最后修改时间的长整数表示（毫秒）
*/
  public long getLastModifiedTimeMillis() {
    return file.lastModified();
  }
  /**
* 获取文件或目录最后修改时间的 LocalDateTime 表示
* @return 最后修改时间的 LocalDateTime 对象
*/
  public LocalDateTime getLastModifiedTime() {
    return LocalDateTime.ofInstant(
      Instant.ofEpochMilli(file.lastModified()),
      ZoneId.systemDefault());
  }
}

文件与目录操作

File类提供了多个方法来执行文件和目录的创建、删除和重命名操作：

示例：

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.nio.file.StandardOpenOption;
import java.util.List;
public class FileAndDirectoryManager {
  private final File fileOrDirectory;
  public FileAndDirectoryManager(String path) {
    this.fileOrDirectory = new File(path);
  }
  /**
* 创建文件或目录
*
* @param createParents 是否创建父目录（如果不存在）
* @return true表示成功创建，false表示创建失败
*/
  public boolean create(boolean createParents) {
    if (fileOrDirectory.isDirectory()) {
      return fileOrDirectory.mkdirs() || fileOrDirectory.isDirectory();
    } else {
      try {
        return fileOrDirectory.getParentFile().mkdirs() && fileOrDirectory.createNewFile();
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
  }
  /**
* 删除文件或目录
*
* @param recursive 是否递归删除目录及其内容
* @return true表示成功删除，false表示删除失败
*/
  public boolean delete(boolean recursive) {
    if (fileOrDirectory.isDirectory() && recursive) {
      File[] children = fileOrDirectory.listFiles();
      if (children != null) {
        for (File child : children) {
          deleteRecursive(child);
        }
      }
    }
    return fileOrDirectory.delete();
  }
  private void deleteRecursive(File file) {
    if (file.isDirectory()) {
      File[] children = file.listFiles();
      if (children != null) {
        for (File child : children) {
          deleteRecursive(child);
        }
      }
    }
    file.delete();
  }
  /**
* 复制文件或目录
*
* @param destination 目标路径
* @param overwrite 是否覆盖已存在的目标文件或目录
* @param recursive 是否递归复制目录及其内容
* @return true表示成功复制，false表示复制失败
* @throws IOException 如果发生I/O错误
*/
  public boolean copy(String destination, boolean overwrite, boolean recursive) throws IOException {
    File destFileOrDir = new File(destination);
    if (fileOrDirectory.isDirectory()) {
      if (!destFileOrDir.exists() || !destFileOrDir.isDirectory()) {
        throw new IOException("Destination must be a directory when copying a directory.");
      }
      if (recursive) {
        File[] children = fileOrDirectory.listFiles();
        if (children != null) {
          for (File child : children) {
            String childDestPath = destination + File.separator + child.getName();
            copy(child.getAbsolutePath(), childDestPath, overwrite, recursive);
          }
        }
      }
    } else {
      Path srcPath = fileOrDirectory.toPath();
      Path destPath = destFileOrDir.toPath();
      if (overwrite || !destFileOrDir.exists()) {
        Files.copy(srcPath, destPath, StandardCopyOption.REPLACE_EXISTING);
      }
    }
    return true;
  }
  /**
  * 移动（重命名）文件或目录
  *
  * @param destination 目标路径
  * @param overwrite 是否覆盖已存在的目标文件或目录
  * @return true表示成功移动，false表示移动失败
  */
  public boolean move(String destination, boolean overwrite) {
    File destFileOrDir = new File(destination);
    if (overwrite && destFileOrDir.exists()) {
      destFileOrDir.delete();
    }
    return fileOrDirectory.renameTo(destFileOrDir);
  }
  /**
  * 列出目录下的所有文件和子目录
  *
  * @return 文件和子目录列表
  */
  public List<File> listFiles() {
    return List.of(fileOrDirectory.listFiles());
  }
  /**
  * 写入文件
  *
  * @param content 要写入的内容
  * @param append 是否追加内容（否则覆盖原有内容）
  * @throws IOException 如果发生I/O错误
  */
  public void writeToFile(String content, boolean append) throws IOException {
    Path path = fileOrDirectory.toPath();
    Files.writeString(path, content, StandardOpenOption.CREATE, append ? StandardOpenOption.APPEND : StandardOpenOption.TRUNCATE_EXISTING);
  }
}

相对路径与绝对路径的使用

相对路径是相对于某个基准目录的路径，而绝对路径是从文件系统的根目录开始的完整路径。在创建File对象或执行文件操作时，使用相对路径还是绝对路径取决于你的具体需求。通常，使用绝对路径可以避免由于当前工作目录不同而导致的问题。

示例

import java.io.File;
import java.io.IOException;

public class PathExample {

  public static void main(String[] args) {
    // 定义相对路径和绝对路径
    String relativePath = "resources/example.txt";
    String absolutePath = "/path/to/your/project/resources/example.txt";

    // 使用相对路径创建File对象
    File relativeFile = new File(relativePath);
    System.out.println("Relative Path: " + relativeFile.getPath());
    System.out.println("Absolute Path: " + relativeFile.getAbsolutePath());

    // 使用绝对路径创建File对象
    File absoluteFile = new File(absolutePath);
    System.out.println("Absolute Path (directly provided): " + absoluteFile.getPath());
    System.out.println("Absolute Path (confirmed): " + absoluteFile.getAbsolutePath());

    // 尝试读取文件内容（这里仅检查文件是否存在）
    try {
      if (relativeFile.exists()) {
        System.out.println("Relative file exists.");
      } else {
        System.out.println("Relative file does not exist.");
      }

      if (absoluteFile.exists()) {
        System.out.println("Absolute file exists.");
      } else {
        System.out.println("Absolute file does not exist.");
      }
    } catch (SecurityException e) {
      e.printStackTrace();
    }
  }
}

分隔符与路径规范化

在构建文件路径时，不同操作系统使用的路径分隔符是不同的（如Windows使用\，而UNIX和Linux使用/）。Java提供了File.separator常量来表示当前操作系统的路径分隔符。此外，File类的getCanonicalPath()和getAbsolutePath()方法可以用于获取规范化或绝对的路径字符串，确保路径的正确性。

示例

import java.io.File;
import java.io.IOException;
public class PathSeparatorAndNormalizationExample {

  public static void main(String[] args) {
    // 获取当前操作系统的路径分隔符
    String separator = File.separator;
    System.out.println("Path separator for this OS: " + separator);

    // 构建跨平台的文件路径
    String folderName = "exampleFolder";
    String fileName = "exampleFile.txt";
    String filePath = folderName + separator + fileName;

    // 创建File对象
    File file = new File(filePath);

    // 获取并打印绝对路径
    System.out.println("Absolute Path: " + file.getAbsolutePath());

    // 获取并打印规范化路径
    try {
      System.out.println("Canonical Path: " + file.getCanonicalPath());
    } catch (IOException e) {
      e.printStackTrace();
    }

    // 演示路径规范化如何处理符号链接等特殊情况
    // 注意：这个示例假设存在符号链接或类似的文件系统特性，这在不同系统和配置下可能有所不同
    File linkedFile = new File("path/to/some/symlink");
    try {
      System.out.println("Linked File Canonical Path: " + linkedFile.getCanonicalPath());
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}