javaEE -6（10000详解文件操作）

一：认识文件

我们先来认识狭义上的文件(file)。针对硬盘这种持久化存储的I/O设备，当我们想要进行数据保存时，往往不是保存成一个整体，而是独立成一个个的单位进行保存，这个独立的单位就被抽象成文件的概念，就类似办公桌上的一份份真实的文件一般。

文件除了有数据内容之外，还有一部分信息，例如文件名、文件类型、文件大小等并不作为文件的数据而存在，我们把这部分信息可以视为文件的元信息。

同时，随着文件越来越多，我们就需要对文件进行管理，如何进行文件的组织呢，一种合乎自然的想法出现了，就是按照层级结构进行组织 —— 也就是我们数据结构中学习过的树形结构。这样，一种专门用来存放管理信息的特殊文件诞生了，也就是我们平时所谓文件夹(folder)或者目录(directory)的概念。

1.1 文件路径

如何在文件系统中如何定位我们的一个唯一的文件就成为当前要解决的问题，这其实很简单，因为从树型结构的角度来看，树中的每个结点都可以被一条从根开始，一直到达的结点的路径所描述，而这种描述方式就被称为文件的绝对路径（absolute path）。

除了可以从根开始进行路径的描述，我们可以从任意结点出发，进行路径的描述，而这种描述方式就被称为相对路径（relative path），相对于当前所在结点的一条路径。

文件的相对路径是以当前所在目录（工作目录）为基准的，每个程序运行的时候都有一个工作目录，IDEA的工作目录默认为当前项目所在的目录

1.2 文件的分类

文件根据其保存数据的不同，被分为不同的类型，我们一般简单的划分为文本文件和二进制文件，分别指代保存被字符集编码的文本和按照标准格式保存的非被字符集编码过的文件。

Windows 操作系统上，会按照文件名中的后缀来确定文件类型以及该类型文件的默认打开程序。但这个习俗并不是通用的，在 OSX、Unix、Linux 等操作系统上，就没有这样的习惯，一般不对文件类型做如此精确地分类。

1.3 文件管理

文件由于被操作系统进行了管理，所以根据不同的用户，会赋予用户不同的对待该文件的权限，一般地可以认为有可读、可写、可执行权限。

Windows 操作系统上，还有一类文件比较特殊，就是平时我们看到的快捷方式（shortcut），这种文件只是对真实文件的一种引用而已。其他操作系统上也有类似的概念，例如，软链接（soft link）等。

最后，很多操作系统为了实现接口的统一性，将所有的 I/O 设备都抽象成了文件的概念，使用这一理念最为知名的就是 Unix、Linux 操作系统 —— 万物皆文件。

二： Java 中操作文件

Java 中通过 java.io.File 类来对一个文件（包括目录）进行抽象的描述。注意，有 File 对象，并不代表真实存在该文件。

下面我们来看看 File 类中的常见属性、构造方法和方法：

1. 属性

2. 构造方法

下面是一个示例 Java 程序来演示如何使用这三个构造方法：

import java.io.File;

public class FileConstructorExample {
    public static void main(String[] args) {
        // 使用父目录 + 孩子文件路径创建一个新的 File 实例
        File file1 = new File("C:/myfolder", "myfile.txt");

        // 使用文件路径创建一个新的 File 实例
        File file2 = new File("C:/myfolder/myfile.txt");

        // 使用父目录 + 孩子文件路径创建一个新的 File 实例，父目录用路径表示
        File parentDir = new File("C:/myfolder");
        File file3 = new File(parentDir, "myfile.txt");

        // 打印文件路径
        System.out.println("file1 路径：" + file1.getPath());
        System.out.println("file2 路径：" + file2.getPath());
        System.out.println("file3 路径：" + file3.getPath());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

方法：

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

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

public class FileDemo {
    public static void main(String[] args) {
        // 创建File对象
        File file = new File("path/to/file.txt");// 并不要求该文件真实存在

        // getParent()
        String parent = file.getParent(); // 返回父目录路径
        System.out.println("父目录路径：" + parent); // 输出：父目录路径：path/to

        // getName()
        String name = file.getName(); // 返回文件名
        System.out.println("文件名：" + name); // 输出：文件名：file.txt

        // getPath()
        String path = file.getPath(); // 返回文件路径
        System.out.println("文件路径：" + path); // 输出：文件路径：path/to/file.txt

        // getAbsolutePath()
        String absolutePath = file.getAbsolutePath(); // 返回绝对路径
        System.out.println("绝对路径：" + absolutePath); // 输出：绝对路径：path/to/file.txt

        // getCanonicalPath()
        try {
            String canonicalPath = file.getCanonicalPath(); // 返回修饰过的绝对路径
            System.out.println("修饰过的绝对路径：" + canonicalPath); // 输出：修饰过的绝对路径：path/to/file.txt
        } catch (IOException e) {
            e.printStackTrace();
        }

        // exists()
        boolean exists = file.exists(); // 判断文件是否存在
        System.out.println("文件是否存在：" + exists); // 输出：文件是否存在：false

        // isDirectory()
        boolean isDirectory = file.isDirectory(); // 判断是否为目录
        System.out.println("是否为目录：" + isDirectory); // 输出：是否为目录：false

        // isFile()
        boolean isFile = file.isFile(); // 判断是否为文件
        System.out.println("是否为文件：" + isFile); // 输出：是否为文件：false

        // createNewFile()
        try {
            boolean created = file.createNewFile(); // 创建空文件
            System.out.println("文件创建是否成功：" + created); // 输出：文件创建是否成功：true
        } catch (IOException e) {
            e.printStackTrace();
        }

        // delete()
        boolean deleted = file.delete(); // 删除文件
        System.out.println("文件是否删除成功：" + deleted); // 输出：文件是否删除成功：true

        // deleteOnExit()
        file.deleteOnExit(); // 标注文件在JVM运行结束时删除

        // list()
        File directory = new File("path/to/directory");
        String[] fileList = directory.list(); // 获取目录下的所有文件名
        System.out.println("目录下的文件名：");
        for (String fileName : fileList) {
            System.out.println(fileName);
        }

        // listFiles()
        File[] files = directory.listFiles(); // 获取目录下的所有文件对象
        System.out.println("目录下的文件路径：");
        for (File fileObject : files) {
            System.out.println(fileObject.getPath());
        }

        // mkdir()
        boolean directoryCreated = directory.mkdir(); // 创建目录
        System.out.println("目录创建是否成功：" + directoryCreated); // 输出：目录创建是否成功：true

        // mkdirs()
        boolean directoriesCreated = directory.mkdirs(); // 创建目录，包括中间目录，mkdir() 的时候，如果中间目录不存在，则无法创建成功; mkdirs() 可以解决这个问题。
        System.out.println("目录创建是否成功：" + directoriesCreated); // 输出：目录创建是否成功：true

        // renameTo()
        File newFile = new File("path/to/newFile.txt");
        boolean renamed = file.renameTo(newFile); // 文件重命名（移动文件）
        System.out.println("文件重命名是否成功：" + renamed); // 输出：文件重命名是否成功：true

        // canRead()
        boolean canRead = file.canRead(); // 判断文件是否可读
        System.out.println("文件是否可读：" + canRead); // 输出：文件是否可读：true

        // canWrite()
        boolean canWrite = file.canWrite(); // 判断文件是否可写
        System.out.println("文件是否可写：" + canWrite); // 输出：文件是否可写：true
    }
}
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

三：文件内容的读写——数据流

3.1 InputStream

1. 方法：

InputStream 只是一个抽象类，要使用还需要具体的实现类。关于 InputStream 的实现类有很多，基本可以认为不同的输入设备都可以对应一个 InputStream 类，我们现在只关心从文件中读取，所以使用 FileInputStream

FileInputStream的构造方法：

对于流的分类我们有两种分法：

1. 按流的方向分类：输入流、输出流
2. 按数据处理单位：字节流、字符流

现在我们理解一下什么是输入，什么是输出：

3.2 字节流

3.2.1字节输入流InputStream

1. read()方法：

   • 读取一个字节的数据，并返回读取的字节值。如果已经达到文件的末尾，则返回-1。

2. read(byte[] b)方法：

   • 将数据读取到给定的字节数组b中，并返回读取的字节数。如果已经达到文件的末尾，则返回-1。

3. read(byte[] b, int off, int len)方法：

   • 将最多len个字节的数据读取到给定的字节数组b的off位置开始的地方，并返回读取的字节数。如果已经达到文件的末尾，则返回-1。

4. close()方法：

   • 关闭输入流，并释放与之关联的系统资源。

下面是这四个方法的使用示例：

import java.io.FileInputStream;
import java.io.IOException;

public class InputStreamExample {
    public static void main(String[] args) {
        String filePath = "C:/Users/86198/Desktop/test.txt";

        try (FileInputStream inputStream = new FileInputStream(filePath)) {
            // 示例1：read()方法
            int singleByte = inputStream.read();
            System.out.println("read() 方法读取的字节值: " + singleByte); //read() 方法读取的字节值: 97

            // 示例2：read(byte[] b)方法
            byte[] byteArray = new byte[8];
            int bytesRead = inputStream.read(byteArray);
            System.out.println("read(byte[] b) 方法读取的字节数: " + bytesRead); //read(byte[] b) 方法读取的字节数: 8

            // 将字节数组转换为字符串并输出
            String content = new String(byteArray);
            System.out.println("读取的内容: " + content); //读取的内容: bcdefg12

            // 示例3：read(byte[] b, int off, int len)方法
            byte[] partialArray = new byte[5];
            int bytesPartialRead = inputStream.read(partialArray, 0, 5);
            System.out.println("read(byte[] b, int off, int len) 方法读取的字节数: " + bytesPartialRead); //read(byte[] b, int off, int len) 方法读取的字节数: 5

            String partialContent = new String(partialArray);
            System.out.println("读取的部分内容: " + partialContent); //读取的部分内容: 34567
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
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

文件内容如下：

3.2.2 字节输出流OutputStream`

• write(byte[] b)：将给定的字节数组写入输出流。

• write(byte[] b, int off, int len)：将指定的字节数组的一部分写入输出流。off 参数表示起始偏移量，len 参数表示要写入的字节数。

• write(int b)：将指定的字节写入输出流。参数b 是一个 int 类型的整数，但只会写入低8位的字节。

• close()：关闭输出流。关闭后，将无法继续写入数据。

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

import java.io.FileOutputStream;
import java.io.IOException;

public class OutputStreamExample {
    public static void main(String[] args) {
        String filePath = "C:/Users/86198/Desktop/test.txt";
        String content = "Hello, World!";

        try {
            // 创建输出流
            FileOutputStream fos = new FileOutputStream(filePath);

            // 使用 write(byte[] b) 方法写入字节数组
            byte[] byteArray = content.getBytes();
            fos.write(byteArray); //文件内容变为 "Hello, World!"

            // 使用 write(byte[] b, int off, int len) 方法写入指定部分字节数组
            String partialContent = "This is a partial content.";
            byte[] partialByteArray = partialContent.getBytes();
            int off = 0; // 起始偏移量
            int len = 10; // 要写入的字节数
            fos.write(partialByteArray, off, len);//在文件内容的后面追加 "This is a"

            // 使用 write(int b) 方法写入单个字节
            int singleByte = 65; // 字符 'A'
            fos.write(singleByte);//在文件内容的后面追加字符 'A'

            // 关闭输出流
            fos.close();

            System.out.println("数据成功写入文件！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

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

3.3 字符流

3.3.1 字符输入流Reader

1. read()：从输入流中读取一个字符，并返回读取的字符的ASCII值。如果已经到达流的末尾，则返回-1。

2. read(char[] cbuf)：从输入流中读取字符，并将它们存储在字符数组 cbuf 中。返回读取的字符数。

3. read(char[] cbuf, int off, int len)：从输入流中读取字符，并将它们存储在字符数组 cbuf 的指定位置 off 开始的位置，并最多读取 len 个字符。返回读取的字符数。

4. read(CharBuffer target)：从输入流中读取字符，并将它们存储在 CharBuffer 中。返回读取的字符数。

5. flush()：刷新输出流并将任何缓冲的输出字符写入到底层流中。

6. close()：关闭输入流，释放与其关联的资源。

代码和字节输入流中的代码效果类似，只不过读取是通过字符而已：

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.nio.CharBuffer;

public class FileReaderExample {

    public static void main(String[] args) {
        String filePath = "C:/Users/86198/Desktop/test.txt";

        try (Reader reader = new FileReader(filePath)) {
            // 1. read()
            int character = reader.read();
            System.out.println("Read character: " + (char) character); //Read character: a

            // 2. read(char[] cbuf)
            char[] buffer = new char[5];
            int numCharsRead = reader.read(buffer);
            System.out.println("Read " + numCharsRead + " characters: " + new String(buffer)); //Read 5 characters: bcdef

            // 3. read(char[] cbuf, int off, int len)
            char[] partialBuffer = new char[5];
            int partialCharsRead = reader.read(partialBuffer, 1, 3);
            System.out.println("Read " + partialCharsRead + " characters: " + new String(partialBuffer)); //Read 3 characters:  g12 

            // 4. read(CharBuffer target)
            CharBuffer charBuffer = CharBuffer.allocate(5);
            int bufferCharsRead = reader.read(charBuffer);
            charBuffer.flip();
            System.out.println("Read " + bufferCharsRead + " characters: " + charBuffer.toString()); //Read 5 characters: 34567

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
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

3.3.2 字符输出流Writer

当使用字符输出流 Writer 进行操作时，可以使用以下方法：

1. write(char[] cbuf)：将字符数组 cbuf 中的字符写入输出流。

2. write(char[] cbuf, int off, int len)：将字符数组 cbuf 中从索引 off 开始的 len 个字符写入输出流。

3. write(int c)：将给定的字符编码 c 写入输出流。

4. write(String str)：将字符串 str 写入输出流。

5. write(String str, int off, int len)：将字符串 str 中从索引 off 开始的 len 个字符写入输出流。

6. flush()：刷新输出流，将缓冲区中的内容立即写入到目标设备中。

7. close()：关闭输出流，并释放相关的系统资源。

代码和字节输出流中的代码效果类似，只不过输出是通过字符而已：

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class WriterExample {
    public static void main(String[] args) {
        String filename = "C:/Users/86198/Desktop/test.txt";

        try (Writer writer = new FileWriter(filename)) {
            char[] charArray = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'};

            // 使用 write(char[] cbuf) 方法将字符数组写入输出流
            writer.write(charArray); //文件内容变为 "Hello World".

            // 使用 write(char[] cbuf, int off, int len) 方法将部分字符数组写入输出流
            writer.write(charArray, 6, 5); //从 `charArray` 数组的索引 6 开始，写入长度为 5 的字符到输出流，文件内容变为 "Hello WorldWorld".

            // 使用 write(int c) 方法将字符编码写入输出流
            writer.write('!'); //文件内容变为 "Hello WorldWorld!".

            String str = " This is a test.";

            // 使用 write(String str) 方法将字符串写入输出流
            writer.write(str); //文件内容变为 "Hello WorldWorld! This is a test.".

            // 使用 write(String str, int off, int len) 方法将部分字符串写入输出流
            writer.write(str, 0, 4); //从字符串的索引 0 开始，写入长度为 4 的部分字符串到输出流，文件内容变为 "Hell WorldWorld! This is a test.".

            // 刷新输出流
            writer.flush(); //调用 `flush()` 方法刷新输出流，确保所有内容都被写入文件。

            System.out.println("数据写入成功！");
        } catch (IOException e) {
            System.out.println("写入数据时出现异常：" + e.getMessage());
        }
    }
}

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

案例：进行普通的文件复制

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class WriterExample {
    public static void main(String[] args) {
        String filename = "C:/Users/86198/Desktop/test.txt";

        try (Writer writer = new FileWriter(filename)) {
            char[] charArray = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'};

            // 使用 write(char[] cbuf) 方法将字符数组写入输出流
            writer.write(charArray); //文件内容变为 "Hello World".

            // 使用 write(char[] cbuf, int off, int len) 方法将部分字符数组写入输出流
            writer.write(charArray, 6, 5); //从 `charArray` 数组的索引 6 开始，写入长度为 5 的字符到输出流，文件内容变为 "Hello WorldWorld".

            // 使用 write(int c) 方法将字符编码写入输出流
            writer.write('!'); //文件内容变为 "Hello WorldWorld!".

            String str = " This is a test.";

            // 使用 write(String str) 方法将字符串写入输出流
            writer.write(str); //文件内容变为 "Hello WorldWorld! This is a test.".

            // 使用 write(String str, int off, int len) 方法将部分字符串写入输出流
            writer.write(str, 0, 4); //从字符串的索引 0 开始，写入长度为 4 的部分字符串到输出流，文件内容变为 "Hell WorldWorld! This is a test. Thi".

            // 刷新输出流
            writer.flush(); //调用 `flush()` 方法刷新输出流，确保所有内容都被写入文件。

            System.out.println("数据写入成功！");
        } catch (IOException e) {
            System.out.println("写入数据时出现异常：" + e.getMessage());
        }
    }
}
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

3.3.3 读写代码参考

1. 如何按字节进行数据读

try (InputStream is = ...) {
  byte[] buf = new byte[1024];
  while (true) {
    int n = is.read(buf);
    if (n == -1) {
      break;
   }
   
    // buf 的 [0, n) 表示读到的数据，按业务进行处理
 }
}
1
2
3
4
5
6
7
8
9
10
11

2. 如何按字节进行数据写

try (OutputStream os = ...) {
  byte[] buf = new byte[1024];
  while (/* 还有未完成的业务数据 */) {
    // 将业务数据填入 buf 中，长度为 n
    int n = ...;
    os.write(buf, 0, n);
 }
  os.flush(); // 进行数据刷新操作
}
1
2
3
4
5
6
7
8
9

3. 如何按字符进行数据读

try (InputStream is = ...) {
  try (Scanner scanner = new Scanner(is, "UTF-8")) {
    while (scanner.hasNextLine()) {
      String line = scanner.nextLine();
     
      // 根据 line 做业务处理
   }
 }
}
1
2
3
4
5
6
7
8
9

4. 如何按字符进行数据写

try (OutputStream os = ...) {
  try (OutputStreamWriter osWriter = new OutputStreamWriter(os, "UTF-8")) {
    try (PrintWriter writer = new PrintWriter(osWriter)) {
      while (/* 还有未完成的业务数据 */) {
        writer.println(...);
     }
      writer.flush(); // 进行数据刷新操作
   }
 }
}
1
2
3
4
5
6
7
8
9
10