javajavase
File类声明在java.io包下

  • File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹)
  • File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，

并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成

  • 后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的”终点”

    常用构造器

    **public File(String filePath)**

    • 以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储

**public File(String parentPath, String childPath)**

  • 以parent为父路径，child为子路径创建File对象

**public File(File parentFile, String childPath)**

  • 根据一个父File对象和子文件路径创建File对象

**public File(URI uri)**

  1. @Test
  2. public void test1() {
  3.     // 构造器1
  4.     File file1 = new File("a.txt");    // @Test中相对位置位于当前module
  5.     File file2 = new File("/Users/cess/idea_project/JavaSenior/mycode/b.txt");
  6.     System.out.println(file1);
  7.     System.out.println(file2);
  9.     // 构造器2：
  10.     File file3 = new File("/Users/cess/idea_project","JavaSenior");
  11.     System.out.println(file3);
  13.     // 构造器3：
  14.     File file4 = new File(file3,"c.txt");
  15.     System.out.println(file4);
  16. }

路径分类

  • 相对路径：相较于某个路径下，指明的路径
  • 绝对路径：包含盘符在内的文件或文件目录的路径

说明

  • IDEA中
    • 如果使用JUnit中的单元测试方法测试，相对路径即为当前Module下
    • 如果使用main()测试，相对路径即为当前的Project下
  • Eclipse中
    • 不管使用单元测试方法还是使用main()测试，相对路径都是当前的Project下

路径分隔符
路径中的每级目录之间用一个路径分隔符隔开

  • windows和DOS系统默认使用“\”来表示
  • UNIX和URL使用“/”来表示
  • Java程序支持跨平台运行，因此路径分隔符要慎用
  • 为了解决这个隐患，File类提供了一个常量**public static final String separator**，根据操作系统，动态的提供分隔符 ```java // windows和DOS系统 File file1 = new File(“E:\io\test.txt”);

// UNIX和URL File file = new File(“E:/io/test.txt”);

// java提供的常量 File file = new File(“E:” + File.separator + “io” + File.separator + “test.txt”);

  1. <a name="AsQ8Q"></a>
  2. ### 常用方法
  4. - **获取**
  6. `**public String getAbsolutePath()**` 获取绝对路径<br />`**public String getPath()**` 获取路径<br />`**public String getName()**` 获取名称<br />`**public String getParent()**` 获取上层文件目录路径。若无，返回null<br />`**public long length()**` 获取文件长度（即：字节数），不能获取目录的长度<br />`**public long lastModified()**` 获取最后一次的修改时间，毫秒值
  8. 如下的两个方法适用于文件目录<br />`**public String[] list()**` 获取指定目录下的所有文件或者文件目录的名称数组<br />`**public File[] listFiles()**` 获取指定目录下的所有文件或者文件目录的File数组
  9. ```java
  10. @Test
  11. public void test2() {
  12.     File file1 = new File("hello.txt");
  13.     System.out.println(file1.getAbsolutePath());
  14.     System.out.println(file1.getPath());
  15.     System.out.println(file1.getName());
  16.     System.out.println(file1.getParent());    // null
  17.     System.out.println(file1.length());
  18.     System.out.println(new Date(file1.lastModified()));
  20.     File file2 = new File("d:\\io\\hi.txt");
  21.     System.out.println(file2.getAbsolutePath());
  22.     System.out.println(file2.getPath());
  23.     System.out.println(file2.getName());
  24.     System.out.println(file2.getParent());
  25.     System.out.println(file2.length());
  26.     System.out.println(file2.lastModified());
  27. }
  29. @Test
  30. public void test3() {
  31.     File file = new File("/Users/cess/idea_project/JavaSenior");
  33.     String[] list = file.list();
  34.     for(String s : list) {
  35.         System.out.println(s);    // 相对路径
  36.     }
  37.     System.out.println();
  39.     File[] files = file.listFiles();
  40.     for(File f : files){
  41.         System.out.println(f);    // 绝对路径
  42.     }
  43. }
  • 重命名

**public boolean renameTo(File dest)** 把文件重命名为指定的文件路径
注意：file1.renameTo(file2)为例：
要想保证返回true，需要file1在硬盘中是存在的且file2不能在硬盘中存在
文件file1的内容挪到了file2，file1不再存在

  1. @Test
  2. public void test4() {
  3.     File file1 = new File("hello.txt");
  4.     File file2 = new File("D:\\io\\hi.txt");
  5.     boolean renameTo = file1.renameTo(file2);
  6.     System.out.println(renameTo);
  7. }
  • 判断

**public boolean isDirectory()** 判断是否是文件目录
**public boolean isFile()** 判断是否是文件
**public boolean exists()** 判断是否存在
**public boolean canRead()** 判断是否可读
**public boolean canWrite()** 判断是否可写
**public boolean isHidden()** 判断是否隐藏

  1. @Test
  2. public void test5() {
  3.     File file1 = new File("hello.txt");    // file存在
  4.     file1 = new File("hello1.txt");    // file1不存在
  5.     System.out.println(file1.isDirectory());    // false-false
  6.     System.out.println(file1.isFile());    // true-false
  7.     System.out.println(file1.exists());
  8.     System.out.println(file1.canRead());
  9.     System.out.println(file1.canWrite());
  10.     System.out.println(file1.isHidden());
  11.     System.out.println();
  13.     File file2 = new File("d:\\io");    // file2是目录
  14.     file2 = new File("d:\\io1");
  15.     System.out.println(file2.isDirectory());    // true
  16.     System.out.println(file2.isFile());    // false
  17.     System.out.println(file2.exists());
  18.     System.out.println(file2.canRead());
  19.     System.out.println(file2.canWrite());
  20.     System.out.println(file2.isHidden());
  21. }
  • 创建

创建硬盘中对应的文件或文件目录
**public boolean createNewFile()** 创建文件。若文件存在则不创建，返回false
**public boolean mkdir()** 创建文件目录

  • 如果此文件目录存在，就不创建了；如果此文件目录的上层目录不存在，也不创建

**public boolean mkdirs()** 创建文件目录

  • 如果此文件目录存在，就不创建了；如果上层文件目录不存在，一并创建
    • 删除

删除磁盘中的文件或文件目录
**public boolean delete()**删除文件或者文件夹
删除注意事项：Java中的删除不走回收站

  1. @Test
  2. public void test6() throws IOException {
  3.     File file1 = new File("hi.txt");
  4.     if(!file1.exists()) {
  5.         // 文件的创建
  6.         file1.createNewFile();
  7.         System.out.println("创建成功");
  8.     }else{
  9.         file1.delete();
  10.         System.out.println("删除成功");
  11.     }
  12. }
  14. @Test
  15. public void test7() {
  16.     // 文件目录的创建
  17.     File file1 = new File("d:\\io\\io1\\io3");
  18.     boolean mkdir = file1.mkdir();
  19.     if(mkdir) {
  20.         System.out.println("创建成功1");
  21.     }
  23.     File file2 = new File("d:\\io\\io1\\io4");
  24.     boolean mkdir1 = file2.mkdirs();
  25.     if(mkdir1) {
  26.         System.out.println("创建成功2");
  27.     }
  29.     // 要想删除成功，io4文件目录下不能有子目录或文件
  30.     File file3 = new File("D:\\io\\io1\\io4");
  31.     file3 = new File("D:\\io\\io1");
  32.     System.out.println(file3.delete());
  33. }

内存解析
File类 - 图1
练习

  1. // 利用Fie构造器，new一个文件目录file 
  2. // 1）在其中创建多个文件和目录 2）编写方法，实现删除fle中指定文件的操作
  3. @Test
  4. public void test1() throws IOException {
  5.     File file = new File("E:\\io\\io1\\hello.txt");
  7.     // 创建一个与file同目录下的另外一个文件，文件名为：haha.txt
  8.     File destFile = new File(file.getParent(),"haha.txt");
  9.     boolean newFile = destFile.createNewFile();
  10.     if(newFile) {
  11.         System.out.println("创建成功！");
  12.     }
  13. }

判断指定目录下是否有后缀名为jpg的文件，如果有，就输出该文件名称

  1. public class FindJPGFileTest {
  2.     @Test
  3.     public void test1() {
  4.         File srcFile = new File("d:\\code");
  5.         String[] fileNames = srcFile.list();
  6.         for(String fileName : fileNames) {
  7.             if(fileName.endsWith(".jpg")) {
  8.                 System.out.println(fileName);
  9.             }
  10.         }
  11.     }
  13.     @Test
  14.     public void test2() {
  15.         File srcFile = new File("d:\\code");
  16.         File[] listFiles = srcFile.listFiles();
  17.         for(File file : listFiles) {
  18.             if(file.getName().endsWith(".jpg")) {
  19.                 System.out.println(file.getAbsolutePath());
  20.             }
  21.         }
  22.     }
  24.     /*
  25.      * File类提供了两个文件过滤器方法
  26.      * public String[] list(FilenameFilter filter)
  27.      * public File[] listFiles(FileFilter filter)
  28.      */
  29.     @Test
  30.     public void test3() {
  31.         File srcFile = new File("d:\\code");
  32.         File[] subFiles = srcFile.listFiles(new FilenameFilter() {
  33.             @Override
  34.             public boolean accept(File dir, String name) {
  35.                 return name.endsWith(".jpg");
  36.             }
  37.         });
  39.         for(File file : subFiles) {
  40.             System.out.println(file.getAbsolutePath());
  41.         }
  42.     }
  43. }

遍历指定目录所有文件名称，包括子文件目录中的文件。
拓展1：并计算指定目录占用空间的大小 拓展2：删除指定文件目录及其下的所有文件

  1. public class ListFileTest {
  2.     public static void main(String[] args) {
  3.         // 递归:文件目录
  4.         // 打印出指定目录所有文件名称，包括子文件目录中的文件
  5.         // 1.创建目录对象
  6.         File file = new File("E:\\test");
  8.         //2.打印子目录
  9.         printSubFile(file);
  10.     }
  12.     /**
  13.      * 递归方法遍历所有目录下的文件
  14.      * @param dir
  15.      */
  16.     public static void printSubFile(File dir) {
  17.         // 打印子目录
  18.         File[] files = dir.listFiles();
  19.         for (File f : files) {
  20.             if (f.isDirectory()) {    // 如果为文件目录，则递归调用自身
  21.                 printSubFile(f);
  22.             } else {
  23.                 System.out.println(f.getAbsolutePath());    // 输出绝对路径
  24.             }
  25.         }
  26.     }
  28.     // 拓展1：求指定目录所在空间的大小
  29.     // 求任意一个目录的总大小
  30.     public long getDirectorySize(File file) {
  31.         // file是文件，那么直接返回file.length()
  32.         // file是目录，把它的下一级的所有大小加起来就是它的总大小
  33.         long size = 0;
  34.         if (file.isFile()) {
  35.             size += file.length();
  36.         } else {
  37.             File[] allFiles = file.listFiles();    // 获取file的下一级
  38.             // 累加all[i]的大小
  39.             for (File f : allFiles) {
  40.                 size += getDirectorySize(f);    //f的大小
  41.             }
  42.         }
  43.         return size;
  44.     }
  46.     /**
  47.      * 拓展2：删除指定的目录
  48.      */
  49.     public void deleteDirectory(File file) {
  50.         // 如果file是文件，直接delete
  51.         // 如果file是目录，先把它的下一级干掉，然后删除自己
  52.         if (file.isDirectory()) {
  53.             File[] allFiles = file.listFiles();
  54.             // 递归调用删除file下一级
  55.             for (File f : allFiles) {
  56.                 deleteDirectory(f);
  57.             }
  58.         } else {
  59.             // 删除文件
  60.             file.delete();
  61.         }
  62.     }
  63. }