文件与IO

文件与IO

在计算机系统中，文件是非常重要的存储方式。

Java的标准库java.io提供了File对象来操作文件和目录。

IO：Input Output 输入与输出流
输入：从硬盘读取数据 输入到内存
输出：从内存读取数据 输出到硬盘（不一定硬盘 网络设备 键盘…）
学习IO流的目的：就为了能够让程序处理一些持久化的数据
流：就是内存与硬盘之间的桥梁，负责数据的运输，数据的流动是单向的

File

构造File对象

File对象既可以表示文件，也可以表示目录。特别要注意的是，构造一个File对象，即使传入的文件或目录不存在，代码也不会出错，因为构造一个File对象，并不会导致任何磁盘操作。只有当我们调用File对象的某些方法的时候，才真正进行磁盘操作。

所创建的文件对象 它只是对路径所表示的文件进行的抽象
并不代表该文件一定存在

// 绝对路径 C:\Users\jameth\Desktop\JavaSE\haha.txt
File file1 = new File("C:\\Users\\jameth\\Desktop\\JavaSE\\haha.txt");

// 相对路径 目标文件的路径与我们当前项目/代码的路径一致
// C:\Users\jameth\Desktop\JavaSE\lala.txt
File file2 = new File("lala.txt");

File currentDir = new File("C:\\Users\\jameth\\Desktop\\JavaSE");
File file5 = new File(currentDir,"heihei.txt");
File file6 = new File("src\\Demo\\Point.java");

//查看抽象路径名表示的文件或目录是否存在
System.out.println(file1.exists());
1
2
3
4
5
6
7
8
9
10
11
12
13

判断文件对象是否存在

File file = new File("JavaSE笔记.txt");
System.out.println(file.exists());  
1
2

获取文件对象的绝对路径

String absPath = file.getAbsolutePath(); 
System.out.println(absPath);
1
2

获取文件路径，怎么给File封装的，结果就是啥

String path = file.getPath();
System.out.println(path);
1
2

获取文件名称

String name = file.getName();   
System.out.println(name);
1
2

获取文件的长度 字节

long size = file.length();  
System.out.println(size);
1
2

最后修改时间 毫秒值

long time = file.lastModified();    
System.out.println(time);
String strDate = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG).format(new Date(time));
System.out.println(strDate);
1
2
3
4

查看文件所在磁盘的容量

file.getTotalSpace();   //当前文件对象所在磁盘的总容量
file.getFreeSpace();    //当前文件对象所在磁盘的剩余容量
file.getUsableSpace();  //当前文件对象所在磁盘的可用容量
file.getTotalSpace() - file.getFreeSpace(); //当前文件对象所在磁盘的已用容量

System.out.println(file.isFile());  //判断该File对象是否是一个已存在的文件
System.out.println(file.isDirectory()); //判断该File对象是否是一个已存在的目录
System.out.println(file.isHidden());
1
2
3
4
5
6
7
8
9

File的创建和删除

File对象如果表示一个目录，可以通过以下方法创建和删除目录：

• boolean createNewFile()：创建当前File对象表示的文件；
• boolean isFile()，判断该File对象是否是一个已存在的文件
• boolean isDirectory()，判断该File对象是否是一个已存在的目录
• boolean mkdir()：创建当前File对象表示的目录；
• boolean mkdirs()：创建当前File对象表示的目录，并在必要时将不存在的父目录也创建出来；
• boolean delete()：删除当前File对象表示的目录，当前目录必须为空才能删除成功。

通过createNewFile()创建一个新文件

File file1 = new File("haha.txt");
//创建一个文件对象
file1.createNewFile();
file1.mkdir();
1
2
3
4

创建一个目录

File file2 = new File("abc");
System.out.println(file2.mkdir());  //创建一级目录
System.out.println(file2.createNewFile());
1
2
3

同一个目录下 File不会创建同名的文件或目录

对于File而言，对象具体是文件还是目录，取决于创建方式，而不是名称

创建多级目录

File file5 = new File("abc\\cba\\kaka\\lala");
file5.mkdirs(); 
new File("abc\\cba\\kaka\\123").mkdirs();
new File("abc\\cba\\kaka\\456").mkdirs();
new File("abc\\cba\\kaka\\789").mkdirs();
1
2
3
4
5

删除文件和目录

System.out.println(file1.delete()); //删除文件 haha.txt

System.out.println(file3.delete()); //删除目录 papa.txt 删除掉了
System.out.println(file4.delete()); //删除文件 tata
System.out.println(file5.delete()); //删除目录 abc\cba\kaka\lala
System.out.println(file2.delete()); //删除目录 abc 并没有删除
1
2
3
4
5
6

delete在删除文件时 如果存在则直接删除
delete在删除目录时 如果目录为空则直接删除 否则删不了
这种删除 是直接从硬盘里删除掉的 不走回收站
如果非要删除一个多级目录的话 只能从递归的角度考虑 从底层开始向上层删除遍历所有目录文件 —递归

文件列表及其过滤器

当File对象表示一个目录时，可以使用list()和listFiles()列出目录下的文件和子目录名。listFiles()提供了一系列重载方法，可以过滤不想要的文件和目录

返回的是当前目录下所有一级文件和子目录的名称数组

File dir = new File("src");

String[] names = dir.list();
for (String name : names) {
    System.out.println(name);
}
1
2
3
4
5
6

返回的是当前目录下所有一级文件和子目录的对象数组

File[] files = dir.listFiles();
for (File file : files) {
    System.out.println(file.getAbsolutePath());
}
1
2
3
4

文件名称过滤器

文件过滤器对目录下文文件过滤

主要是按照文件/目录的名称String进行过滤

String[] namse4 = dir4.list(new FilenameFilter() {
    //dir指的是当前被展开的目录 - dir4
    //name指的是该目录下 每一个子文件/子目录对象的名字
    @Override
    public boolean accept(File dir, String name) {
        return name.endsWith(".jpg") || name.endsWith(".png");
    }
});
for (String name : namse4) {
    System.out.println(name);
}
1
2
3
4
5
6
7
8
9
10
11

文件属性过滤器

主要对文件的属性进行筛选过滤

File[] files4 = dir4.listFiles(new FileFilter() {
    //pathname 指的就是当前目录下的某一个文件/目录对象
    @Override
    public boolean accept(File pathname) {
        //                return pathname.length() >= 1024 * 20;
        //                return pathname.getName().startsWith("Test");
        return pathname.length() >= 20480 && pathname.getName().endsWith(".png");
    }
});
for (File file : files4) {
    System.out.println(file.getName() + "==>" + file.length());
}
1
2
3
4
5
6
7
8
9
10
11
12
13

遍历文件和目录

遍历所有目录下指定文件 —递归

private static void test01() {
    //遍历所有内容 - 递归
    File dir = new File("C:\\Users\\jameth\\Desktop\\TestData");
    travelDir(dir, 0);
}

private static void travelDir(File dir, int level) {
    System.out.println(printLevel(level) + "【" + dir.getName() + "】");
    File[] files = dir.listFiles();
    if (files != null && files.length > 0) {
        for (File file : files) {
            if (file.isFile()) {    //是文件 直接打印名称
                System.out.println(printLevel(level + 1) + file.getName());
            } else {        //是目录 接着递归执行
                travelDir(file, level + 1);
            }
        }
    }
}

private static String printLevel(int level) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i  < level; i++) {
        sb.append("-------");
    }
    return sb.toString();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

遍历所有.java文件 - 递归

private static void test02() {
        //遍历所有.java文件 - 递归
        File dir = new File("D:\\");
        travelJavaFiles(dir);
    }

    private static void travelJavaFiles(File dir) {
        File[] files = dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.isDirectory() || pathname.getName().endsWith(".ppt") || pathname.getName().endsWith(".pptx");
            }
        });
        if (files != null && files.length > 0) {
            for (File file : files) {
                if (file.isDirectory()) {
                    travelJavaFiles(file);
                } else {
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

用队列遍历所有目录文件

private static void test03() {
    //遍历所有文件 - 迭代
    LinkedList<File> queue = new LinkedList<>();
    File dir = new File("C:\\Users\\jameth\\Desktop\\TestData");
    queue.offer(dir);

    while (!queue.isEmpty()) {
        File cur = queue.poll();
        System.out.println("【" + cur.getName() + "】");
        File[] files = cur.listFiles();
        if (files != null && files.length > 0) {
            for (File file : files) {
                if (file.isFile()) {
                    System.out.println(file.getName());
                } else {
                    queue.offer(file);
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

删除指定目录 —递归

private static void test04() {
    //删除指定的目录 - 递归
    File dir = new File("文件路径");
    deleteDir(dir);
}

private static void deleteDir(File dir) {
    File[] files = dir.listFiles();
    if (files != null && files.length > 0) {
        for (File file : files) {
            if (file.isFile()) {    //是文件，直接删除
                System.out.println(file.getName() + "已被删除");
                file.delete();
            } else {        //是目录 接着递归删除
                deleteDir(file);
            }
        }
    }
    System.out.println(dir.getName() + "已被删除");
    dir.delete();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

删除所有.java文件 - 递归

private static void test05() {
    
    File dir = new File("文件路径");
    deleteJavaFiles(dir);
}

private static void deleteJavaFiles(File dir) {
    File[] files = dir.listFiles(new FileFilter() {
        @Override
        public boolean accept(File pathname) {
            return pathname.isDirectory() || pathname.getName().endsWith(".java");
        }
    });
    if (files != null && files.length > 0) {
        for (File file : files) {
            if (file.isDirectory()) {
                deleteJavaFiles(file);
            } else {
                System.out.println(file.getName() + "已被删除");
                file.delete();
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

删除所有文件 - 迭代

private static void test06() {
    LinkedList<File> queue = new LinkedList<>();
    File dir = new File("文件路径");
    queue.offer(dir);
    LinkedList<File> stack = new LinkedList<>();

    while (!queue.isEmpty()) {
        File cur = queue.poll();
        stack.push(cur);
        File[] files = cur.listFiles();
        if (files != null && files.length > 0) {
            for (File file : files) {
                if (file.isFile()) {
                    System.out.println(file.getName() + "已被删除");
                    file.delete();
                } else {
                    queue.offer(file);
                }
            }
        }
    }
    while (!stack.isEmpty()) {
        File cur = stack.pop();
        System.out.println(cur.getName() + "已被删除");
        cur.delete();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

• 创建File对象本身不涉及IO操作；
• 可以获取路径／绝对路径／规范路径：getPath()/getAbsolutePath()/getCanonicalPath()；
• 可以获取目录的文件和子目录：list()/listFiles()；
• 可以创建或删除文件和目录。