1.java IO包

Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。

Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。

文件依靠流进行传输，就像快递依托于快递员进行分发🍳

Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。

下图是一个描述输入流和输出流的类层次图。

---

2.创建文件

方式一：

/**
 * 创建文件，第一种方式
 */
@Test
public void createFile01() {
    String filePath = "D://1.txt";
    File file = new File(filePath);
    try {
        file.createNewFile();
        System.out.println("文件创建成功！");
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

第二种方式：

/**
 * 创建文件，第二种方式
 */
@Test
public void createFile02() {
    File parentFile = new File("D:\\");
    String fileName = "news.txt";
    File file = new File(parentFile, fileName);
    try {
        file.createNewFile();
        System.out.println("文件创建成功！");
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

第三种方式：

/**
 * 创建文件，第三种方式
 */
@Test
public void createFile03() {
    String parentPath = "D:\\";
    String fileName = "my.txt";
    File file = new File(parentPath, fileName);
    try {
        file.createNewFile();
        System.out.println("文件创建成功！");
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

3.获取文件信息

示例代码：

/**
 * 获取文件信息
 */
@Test
public void info() {
    // 创建文件对象
    File file = new File("D:\\news.txt");
    // 获取文件名字
    System.out.println(file.getName());
    // 获取文件路径
    System.out.println(file.getAbsolutePath());
    // 获取文件父亲目录
    System.out.println(file.getParent());
    // 获取文件大小（字节）
    System.out.println(file.length());
    // 文件是否存在
    System.out.println(file.exists());
    // 是不是一个文件
    System.out.println(file.isFile());
    // 是不是一个目录
    System.out.println(file.isDirectory());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

---

4.目录操作

案例一：判断指定目标是否存在，如果存在就删除✨

// 判断指定目标是否存在，如果存在就删除
String filePath = "D:\\news.txt";
File file = new File(filePath);
if (file.exists()) {
    if (file.delete()) {
        System.out.println("删除成功！");
    } else {
        System.out.println("删除失败！");
    }
} else {
    System.out.println("文件不存在！");
}
1
2
3
4
5
6
7
8
9
10
11
12

案例二：判断目录是否存在，如果存在即删除🤖

// 判断目录是否存在，如果存在即删除
String dirPath = "D:\\demo";
File file1 = new File(dirPath);
if (file1.exists()) {
    if (file1.delete()) {
        System.out.println("删除成功！");
    } else {
        System.out.println("删除失败！");
    }
} else {
    System.out.println("目录不存在！");
}
1
2
3
4
5
6
7
8
9
10
11
12

案例三：判断指定目录是否存在，不存在就创建目录🎈

// 判断指定目录是否存在，不存在就创建目录
String persondir = "D:\\demo\\a\\b\\c";
File file2 = new File(persondir);
if (file2.exists()) {
    System.out.println("该目录存在！");
} else {
    if (file2.mkdirs()) {
        System.out.println("目录创建成功！");
    } else {
        System.out.println("目录创建失败！");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

注意：创建多级目录，使用mkdirs，创建一级目录使用mkdir🍔

---

4.字节输入流InputStream

InputStream抽象类是所有类字节输入流的超类

• FileInputStream 文件输入流
• BufferedInputStream 缓冲字节输入流
• ObjectInputStream 对象字节输入流

FileInputStream

文件输入流，从文件中读取数据，示例代码：

单个字节的读取，效率较低：

/**
 * read()读文件
 */
@Test
public void readFile01() throws IOException {
    String filePath = "D:\\hacker.txt";
    int readData = 0;
    FileInputStream fileInputStream = null;
    try {
        fileInputStream = new FileInputStream(filePath);
        // 读文件，一个字符一个字符读取，返回字符的ASCII码，文件尾部返回-1
        while ((readData = fileInputStream.read()) != -1) {
            System.out.print((char)readData);
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        // 关闭流资源
        fileInputStream.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

注意：使用字节流的方式，无法读取文件中的中文字符，如需读取中文字符，最好使用字符流的方式😈

使用byte数组的方式读取，这使得可以读取中文，并且有效的提升读取效率：

/**
 * read(byte[] b)读文件
 * 支持多字节读取，提升效率
 */
@Test
public void readFile02() throws IOException {
    String filePath = "D:\\hacker.txt";
    int readData = 0;
    int readLen = 0;
    // 字节数组
    byte[] bytes = new byte[8]; // 一次最多读取8个字节

    FileInputStream fileInputStream = null;
    try {
        fileInputStream = new FileInputStream(filePath);
        // 读文件，从字节数组中直接读取
        // 如果读取正常，返回实际读取的字节数
        while ((readLen = fileInputStream.read(bytes)) != -1) {
            System.out.print(new String(bytes, 0, readLen));
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        // 关闭流资源
        fileInputStream.close();
    }
}
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

---

5.字节输出流FileOutputStream

使用示例：（向hacker.txt文件中加入数据）

/**
 * FileOutputStream数据写入文件
 * 如果该文件不存在，则创建该文件
 */
@Test
public void writeFile() throws IOException {
    String filePath = "D:\\hacker.txt";
    FileOutputStream fileOutputStream = null;
    try {
        fileOutputStream = new FileOutputStream(filePath);
        // 写入一个字节
        // fileOutputStream.write('G');
        // 写入一个字符串
        String s = "hello hacker!";
        // fileOutputStream.write(s.getBytes());
        // 写入字符串指定范围的字符
        fileOutputStream.write(s.getBytes(),0,3);
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    } finally {
        assert fileOutputStream != null;
        fileOutputStream.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

我们发现，使用这样的FileOutputStream构造器无法实现向文件中追加内容，只能进行覆盖，我们可以在初始化对象的时候这样解决：

fileOutputStream = new FileOutputStream(filePath,true);
1

---

6.模拟文件拷贝

我们可以结合字节输入和输出流模拟一个文件拷贝的程序：

/**
 * 文件拷贝
 * 思路：
 * 创建文件的输入流，将文件读取到程序
 * 创建文件的输出流，将读取到的文件数据写入到指定的文件
 */
@Test
public void Copy() throws IOException {
    String srcFilePath = "D:\\hacker.txt";
    String destFilePath = "D:\\hello.txt";
    FileInputStream fileInputStream = null;
    FileOutputStream fileOutputStream = null;
    try {
        fileInputStream = new FileInputStream(srcFilePath);
        fileOutputStream = new FileOutputStream(destFilePath);
        // 定义字节数组，提高效率
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = fileInputStream.read(buf)) != -1) {
            // 边读边写
            fileOutputStream.write(buf, 0, readLen);
        }
        System.out.println("拷贝成功！");
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        if (fileInputStream != null){
            fileInputStream.close();
        }
        if (fileOutputStream != null) {
            fileOutputStream.close();
        }
    }
}
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

---

7.字符输入流FileReader

字符输入流FileReader用于从文件中读取数据

示例：

import java.io.FileReader;
import java.io.IOException;

/**
 * 字符输入流
 */
public class FileReaderTest {

    public static void main(String[] args) throws IOException {
        String filePath = "D:\\hacker.txt";
        FileReader fileReader = null;
        // 循环读取内容
        int readLen = 0;
        char[] buf = new char[32];
        fileReader = new FileReader(filePath);
        while ((readLen = fileReader.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readLen));
        }
        fileReader.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

---

8.字符输出流FileWriter

字符输出流FileWrite用于写数据到文件中：

示例：

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

/**
 * 字符输出流
 */
public class FileWriteTest {
    public static void main(String[] args) throws IOException {
        String filePath = "D:\\hacker.txt";
        // 创建对象
        FileWriter fileWriter = null;
        try {
            char[] chars = {'a', 'b', 'c'};
            fileWriter = new FileWriter(filePath, true);
            // 写入单个字符
            // fileWriter.write('H');
            // 写入字符数组
            // fileWriter.write(chars);
            // 指定数组的范围写入
            // fileWriter.write(chars, 0, 2);
            // 写入字符串
            // fileWriter.write("解放军万岁！");
            // 指定字符串的写入范围
            fileWriter.write("hacker club", 0, 5);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            // FileWriter是需要强制关闭文件或刷新流的，否则数据会保存失败
            fileWriter.close();
        }
    }
}
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

使用FileWriter，记得关闭文件或者刷新流！😋