(点击跳转即可哦)

java学习专栏

LeetCode刷题专栏

---

文件IO实例

复习

1. 关于文件管理信息——File对象：文件系统树的遍历、增、删、改、查
2. 输入、输出的模型

InputStream 读取数据流的设备。将输入设备抽象成数据流的源头

1. 数据被抽象成流式(Stream)的形式
2. 需要右内存空间，存放读取到的数据：一个变量的空间 或者一个数组的空间
3. EOS : 表示数据已经被读完。 VS 本次暂时没有读到数据
4. 可以将InputStream 接上其他的数据处理对象

OutputStream 将内存中的数据，通过写入数据流的设备，最终将数据写到输出设备中。

1. 写的时候，为了同步内存和输出设备之间的写入速度差，一般是存在缓冲区（buffer）的。减少写的频次，提高写的速度
2. 所以冲刷缓冲区(flush) 的 操作非常重要

3. 字符集(ASCII 和 Unicode) 和字符集编码(ASCII、GBK、UTF-8)

---

1 给定路径，查找文件名中 包含指定的字符的文件列表，并根据用户的选择，决定是否删除

思路：

1. 从一个树的根开始，遍历整颗树
2. 将每个结点的名字 匹配 查找条件
3. 如果符合条件，就保存File对象
4. 遍历完成后，得到一组符合条件的File对象
5. 一次询问用户，这些对象的下一步处理对象

package com.djl.io;
/**
 * 扫描指定目录，并找到名称中包含指定字符的所有普通文件（不包含目录），并且后续询问用户是否要
 * 删除该文件
 */

import java.io.File;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) throws Exception{
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要扫描的目录：");
        String dir = sc.nextLine();
        File file = new File(dir);
        if(!file.isDirectory()){
            System.out.println("要扫描的路径不是目录或者不存在");
            return;
        }
        System.out.println("请输入文件名要包含的字符：");
        String fileName = sc.nextLine();
        Deque<File> list = new ArrayDeque<>();
        //这个方法会把符合条件的文件路径存储到list中
        findFile(file,fileName,list);
        while (!list.isEmpty()){
            File file1 = list.poll();
            System.out.println("是否删除" + file1.getAbsolutePath() + "  y/n");
            String pd = sc.nextLine();
            if(pd.toLowerCase().equals("y")){
                file1.delete();
                System.out.println("删除成功");
            }
        }
    }

    private static void findFile(File file, String fileName, Deque<File> list) throws Exception{
        File[] files = file.listFiles();
        if(files == null || files.length == 0){
            return;
        }
        for(File f : files){
            if(f.isDirectory()){
                findFile(f,fileName,list);
            }else {
                String name = f.getName();
                if(name.contains(fileName)){
                    list.offer(f);
                }
            }
        }
    }
}
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

2 一个文件的复制

给定两个路径：源文件路径（必须存在）、目标路径（必须不存在 && 目录存在）

源文件 必须是普通文件，不是目录文件

思路：

1. 由于只是进行复制，所以根本不考虑文件的内容具体是什么
2. 所以我们要做的是：遍历（从源文件中读取数据，写入目标文件）直到所有的数据全部写完

package com.djl.io;


import java.io.*;
//文件的复制
public class Test2 {
    public static void main(String[] args) throws Exception{
        File oldFile = new File("D:/简历/Java开发工程师简历.docx");
        File newFile = new File("D:/简历/2/简历.docx");
        //统计复制需要的时间
        long sta = System.currentTimeMillis();
        //准备好的桶
        byte[] bur = new byte[1024];
        int count = 0;
        try (InputStream is = new FileInputStream(oldFile)){
            try(OutputStream os = new FileOutputStream(newFile)){
                while (true){
                    int n = is.read(bur);
                    count += n;
                    if(n == -1){
                        break;
                    }
                    os.write(bur);
                }
                os.flush();
            }
        }
        long end = System.currentTimeMillis();
        long ms = end-sta;
        double s = ms/1000.0;
        System.out.println("复制时间是："+s+"ms");

    }
}
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
28
29
30
31
32
33
34

3 一个目录的复制

给定两个路径： 源文件路径 （必须存在 && 是目录）、目标路径（必须不存在 && 父目录存在）

思路：

if(目录) ：继续递归 + 目标的相对位置创建目录

if(文件)： 目标的相对位置，进行文件的复制

package com.djl.io;

//目录的复制

import java.io.*;

public class Test2_copyDir {
    static File oldFile = new File("D:/简历");
    static File newFile = new File("D:/简历/2");
    public static void main(String[] args) throws Exception{
        traversal(oldFile);
    }

    private static void traversal(File oldFile) throws Exception{
        File[] oldFiles = oldFile.listFiles();
        if(oldFiles == null){
            System.out.println("目录为空");
            return;
        }
        for(File file : oldFiles){
            String oldFilePath = oldFile.getCanonicalPath();
            String filePath = file.getCanonicalPath();
            String newFilePath = newFile.getCanonicalPath();

            String rever = filePath.substring(oldFilePath.length());
            newFilePath = newFilePath + rever;
            File oneNewFile = new File(newFilePath);
            if(file.isDirectory()){
                oneNewFile.mkdir();
                traversal(file);
            }else if(file.isFile()){
                copyFile(file,oneNewFile);
            }

        }
    }

    private static void copyFile(File file, File oneNewFile) throws Exception{
        try(InputStream is = new FileInputStream(file)){
            try(OutputStream os = new FileOutputStream(oneNewFile)){
                while (true){
                    byte[] bur = new byte[1024];
                    int n = is.read(bur);
                    if(n == -1){
                        break;
                    }
                    os.write(bur);
                }
                os.flush();
            }
        }
    }
}
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

---

要是对大家有所帮助的话，请帮我点个赞吧。