学习目标:

掌握IO体系及分类
熟练掌握字节流
熟悉字符流
熟悉其他流

IO概述#

什么是IO?#

input : 输入读

output: 输出写

为什么有IO?#

在操作系统中，一切需要永久保存的数据都以文件的形式存储。需要长久保存的文件数据，存储在外部设备。但是需要读入内存才能显示这些数据同时，内存的大小有限，因此常常需要在内存和外设之间交换数据，即I/O

java中如何实现IO功能#

Java流模型

IO的分类#

按流向分(以内存为参照物)

输出流: 内存---> 磁盘
输入流: 磁盘---> 内存

按照数据类型分

字节流: 逻辑单位是字节,(1B = 8bit 0000 0000)
字符流: 逻辑单位是字符(理解为一种文化符号,abc , “你”, “の”)

4个抽象基类#

字节输出流: OutputStream

字节输入流: InputStream

字符输出流: Writer

字符输入流: Reader

由这4个抽象基类派生的子类都是以其父类名作为后缀的

如：InputStream的子类FileInputStream。如：Reader的子类FileReader

什么时候用什么流?#

一般来讲, 纯文本文件用字符流 .txt .java .cpp

其他情况用字节流(字节流是万能的) .word .ppt .mp4 .mp3 .jpg . png .exe

字节流#

字节输出流#

抽象基类OutputStream#

此抽象类是表示输出字节流的所有类的超类

继承关系

成员方法

void	close() 关闭此输出流并释放与此流有关的所有系统资源。
void	flush() 刷新此输出流并强制写出所有缓冲的输出字节。
void	write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。
void	write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
abstract void	write(int b) 将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。

具体子类#

FileOutputStream文件字节输出流#

用于将数据写入 File

继承关系

构造方法

FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(String fileName) 创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(String name, boolean append) 创建一个向具有指定 name 的文件中写入数据的输出文件流 append - 如果为 true，则将字节写入文件末尾处，而不是写入文件开始处

成员方法

void	write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。
void	write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
abstract void	write(int b) 将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。

Demo

1
package _16io01.com.cskaoyan.bytestream._01fileoutputstream;
2

3
import java.io.File;
4
import java.io.FileNotFoundException;
5
import java.io.FileOutputStream;
6
import java.io.IOException;
7

8
/**
9
 * @description:
10
 * @author: 景天
11
 * @date: 2022/10/15 9:13
12
 **/
13
/*
14
写数据的步骤
15
1.创建输出流对象
16
2.write
17
3.释放资源 close
18
 */
19
public class Demo {
20
    public static void main(String[] args) throws IOException {
21
        //1.创建输出流对象
22
        //FileOutputStream out = new FileOutputStream(new File("D:\\workspace2\\java46th\\a.txt"));
23
        FileOutputStream out = new FileOutputStream("b.txt");
24

25
        //2.write
26
        // write(int b) 写单个字节
27
        //out.write(97);
28

29

30
        // write(byte[] b) 批量写
31
        String s = "abc";
32
        byte[] bytes = s.getBytes();
33
        out.write(bytes);
34

35
        // write(byte [] b , int off , int len) 写字节数组的部分
36
        out.write(bytes, 1, 2);
37

38
        //3.释放资源 close
39
        out.close();
40
    }
41
}

注意事项#

当我们创建一个输出流对象的时候,发生了什么?
- jvm向操作系统中看这个文件是否存在
- 如果文件不存在, 帮我们创建
- 文件已经存在, 覆盖重新开始写

如何实现文件追加功能?

借助于带append参数的构造方法

1
package _16io01.com.cskaoyan.bytestream._01fileoutputstream;
2

3
import java.io.FileOutputStream;
4
import java.io.IOException;
5

6
/**
7
 * @description:
8
 * @author: 景天
9
 * @date: 2022/10/15 10:55
10
 **/
11
/*
12
实现文件追加功能
13
 */
14
public class Demo2 {
15
    public static void main(String[] args) throws IOException {
16
        // 使用带append的构造方法
17
        // 创建输出流对象
18
        FileOutputStream out = new FileOutputStream("a.txt", true);
19
        // write
20
        out.write(100);
21
        // close
22
        out.close();
23
    }
24
}

如何实现换行功能

1
package _16io01.com.cskaoyan.bytestream._01fileoutputstream;
2

3
import java.io.FileOutputStream;
4
import java.io.IOException;
5

6
/**
7
 * @description:
8
 * @author: 景天
9
 * @date: 2022/10/15 10:57
10
 **/
11
/*
12
实现换行功能
13
 */
14
public class Demo3 {
15
    public static void main(String[] args) throws IOException {
16
        // 创建输出流对象
17
        FileOutputStream out = new FileOutputStream("a.txt");
18
        out.write("abcd".getBytes());
19
        // write 写换行符
20
        // \r\n
21
        out.write("\r\n".getBytes());
22
        out.write(97);
23

24
        out.write("\r".getBytes());
25
        out.write(97);
26

27
        out.write("\n".getBytes());
28
        out.write(97);
29

30
        // 使用系统默认换行符
31
        out.write(System.lineSeparator().getBytes());
32
        out.write(97);
33

34
        // close
35
        out.close();
36
    }
37
}

如何异常处理

try-catch-finally

1
package _16io01.com.cskaoyan.bytestream._01fileoutputstream;
2

3
import java.io.FileNotFoundException;
4
import java.io.FileOutputStream;
5
import java.io.IOException;
6
import java.io.OutputStream;
7

8
/**
9
 * @description:
10
 * @author: 景天
11
 * @date: 2022/10/15 11:04
12
 **/
13
/*
14
try-catch
15
 */
16
public class Demo4 {
17
    public static void main(String[] args) {
18
        // 创建输出流对象
19
        FileOutputStream out = null;
20
        try {
21
            // xxxxxx
22
            // xxxx
23
            out = new FileOutputStream("a.txt");
24
            // write
25
            out.write("aaaa".getBytes());
26
        } catch (FileNotFoundException e) {
27
            e.printStackTrace();
28
        } catch (IOException e) {
29
            e.printStackTrace();
30
        }finally {
31
            // close
32
            try {
33
                if (out != null) {
34
                    out.close();
35
                }
36
            } catch (IOException e) {
37
                e.printStackTrace();
38
            }
39
        }
40

41
    }
42
}

try-with-resources

1
语法
2
try(资源,只要实现了AutoCloseable接口的类){
3
 //可能出现异常的代码
4
 // 当出了try代码块的时候 close方法会自动执行 资源会被自动释放
5
}catch(){
6

7
}

1
package _16io01.com.cskaoyan.bytestream._01fileoutputstream;
2

3
import java.io.FileNotFoundException;
4
import java.io.FileOutputStream;
5
import java.io.IOException;
6

7
/**
8
 * @description:
9
 * @author: 景天
10
 * @date: 2022/10/15 11:13
11
 **/
12
/*
13
try-with-resources
14
 */
15
public class Demo5 {
16
    public static void main(String[] args) {
17
        try(FileOutputStream out = new FileOutputStream("a.txt")) {
18
            // write数据
19
            out.write("abc".getBytes());
20
        } catch (FileNotFoundException e) {
21
            e.printStackTrace();
22
        } catch (IOException e) {
23
            e.printStackTrace();
24
        }
25
    }
26
}

验证自动执行

1
package _16io01.com.cskaoyan.bytestream._01fileoutputstream;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/15 11:15
7
 **/
8
/*
9
验证close方法自动执行
10
 */
11
public class Demo6 {
12
    public static void main(String[] args) {
13
        try (A a = new A()){
14
            // 调用func 不调用close
15
            a.func();
16
        } catch (Exception e) {
17
            e.printStackTrace();
18
        }
19
    }
20
}
21

22
class A implements AutoCloseable{
23

24
    @Override
25
    public void close() throws Exception {
26
        System.out.println("close执行了");
27
    }
28

29
    public void func(){
30
        System.out.println("func方法执行了");
31
    }
32
}

为什么要close?
- jvm使用了不属于jvm的资源, 不能通过GC回收, 只能通过close显式的释放资源.

BufferedOutputStream缓冲字节输出流#

该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。

继承关系

构造方法

BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。默认缓冲区大小是8KB
BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。指定缓冲区size大小

成员方法

3个write方法

write(int b)

write(byte[] b)

write(byte[] b, int off, int len)

Demo

1
package _17io02.com.cskaoyan.bytestream._03buffer;
2

3
import java.io.BufferedOutputStream;
4
import java.io.File;
5
import java.io.FileOutputStream;
6
import java.io.IOException;
7

8
/**
9
 * @description:
10
 * @author: 景天
11
 * @date: 2022/10/17 11:02
12
 **/
13
/*
14
使用缓冲输出流
15
 */
16
public class Demo {
17
    public static void main(String[] args) throws IOException {
18
        // 创建输出流对象
19
        //FileOutputStream fileOutputStream = new FileOutputStream("a.txt");
20
        //BufferedOutputStream out = new BufferedOutputStream(fileOutputStream);
21

22
        BufferedOutputStream out =
23
                new BufferedOutputStream(new FileOutputStream("a.txt"));
24

25
        // write
26
        // 写单个字节
27
        out.write(97);
28
        out.write(98);
29

30
        out.write("yyds".getBytes());
31

32
        // flush
33
        out.flush();
34

35
        // close
36
        out.close();
37
    }
38
}

注意：

使用所有带缓冲区的输出流, 记得flush操作
执行close方法会自动执行flush
- image-20221017111016747

缓冲区满了会自动刷新

1
public class Demo2 {
2
    public static void main(String[] args) throws IOException {
3
        // 使用指定缓冲区
4
        BufferedOutputStream out =
5
                new BufferedOutputStream(new FileOutputStream("a.txt"), 4);
6
        // write
7
        out.write("abcdef".getBytes());
8

9
        // flush
10

11
        // close
12
    }
13
}

字节输入流#

抽象基类InputStream#

此抽象类是表示字节输入流的所有类的超类。

继承关系

成员方法

abstract int	read() 从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。在输入数据可用、检测到流末尾或者抛出异常前，此方法一直阻塞。返回值代表了读取到的字节值 readData
int	read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。读入缓冲区的总字节数；如果因为已经到达流末尾而不再有数据可用，则返回 -1。返回值表示读取的字节的个数 readCount
int	read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组。

具体子类#

FileInputStream文件字节输入流#

FileInputStream 从文件系统中的某个文件中获得输入字节

继承关系

构造方法

FileInputStream(File file) 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
FileInputStream(String fileName) 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

成员方法

abstract int	read() 从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。在输入数据可用、检测到流末尾或者抛出异常前，此方法一直阻塞。返回值代表了读取到的字节值 readData
int	read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。读入缓冲区的总字节数；如果因为已经到达流末尾而不再有数据可用，则返回 -1。返回值表示读取的字节的个数 readCount
int	read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组。

Demo

1
package _16io01.com.cskaoyan.bytestream._02fileinputstream;
2

3
import java.io.FileInputStream;
4
import java.io.IOException;
5

6
/**
7
 * @description:
8
 * @author: 景天
9
 * @date: 2022/10/15 11:33
10
 **/
11
/*
12
读取数据的步骤
13
1.创建输入流对象
14
2.read
15
3.close释放资源
16
 */
17
public class Demo {
18
    public static void main(String[] args) throws IOException {
19
        //1.创建输入流对象
20
        FileInputStream in = new FileInputStream("a.txt");
21
        //2.read
22
        // read() 读取单字节
23
        // readData 表示读取的字节值
24
        // readSingle(in);
25

26
        // read(byte[])
27
        // readMulti(in);
28

29

30
        // read(byte[],int off,int len)
31
        //3.close释放资源
32
        in.close();
33
    }
34

35
    private static void readMulti(FileInputStream in) throws IOException {
36
        byte[] bytes = new byte[1024];
37
        // readCount 表示读取到的字节的个数
38
        int readCount = in.read(bytes);
39
        System.out.println("readCount = " + readCount);
40
        String s = new String(bytes);
41
        System.out.println(s);
42
    }
43

44
    private static void readSingle(FileInputStream in) throws IOException {
45
        int readData = in.read();
46
        System.out.println(((char) readData));
47

48
        int readData2 = in.read();
49
        System.out.println(((char) readData2));
50

51
        int readData3 = in.read();
52
        System.out.println(((char) readData3));
53

54
        int readData4 = in.read();
55
        System.out.println(readData4);
56
    }
57
}

1
package _16io01.com.cskaoyan.bytestream._02fileinputstream;
2

3

4
import java.io.FileInputStream;
5
import java.io.IOException;
6

7
/**
8
 * @description:
9
 * @author: 景天
10
 * @date: 2022/10/15 11:43
11
 **/
12

13
public class Demo2 {
14
    public static void main(String[] args) throws IOException {
15
        // 创建输入流对象
16
        FileInputStream in = new FileInputStream("a.txt");
17

18
        // read
19
        // read(byte[])
20
        byte[] bytes = new byte[4];
21
        int readCount = in.read(bytes);
22
        System.out.println(new String(bytes));
23

24
        int readCount2 = in.read(bytes);
25
        System.out.println(new String(bytes,0,readCount2));
26

27
        // close
28
        in.close();
29
    }
30
}

循环读取

1
package _17io02.com.cskaoyan.bytestream._01readwhile;
2

3
import java.io.FileInputStream;
4
import java.io.IOException;
5

6
/**
7
 * @description:
8
 * @author: 景天
9
 * @date: 2022/10/17 9:43
10
 **/
11

12
/*
13
循环读取数据
14
 */
15
public class Demo {
16
    public static void main(String[] args) throws IOException {
17
        // 创建输入流对象
18
        FileInputStream in = new FileInputStream("a.txt");
19

20
        // 循环
21
        // readWhile1(in);
22

23
        // 新的方式
24
        // 单字节读取
25
        // readWhile2(in);
26

27
        // 字节数组方式
28
        int readCount;
29
        byte[] bytes = new byte[1024];
30
        while ((readCount = in.read(bytes)) != -1) {
31
            System.out.println(new String(bytes,0,readCount));
32
        }
33

34

35
        // close
36
        in.close();
37
    }
38

39
    private static void readWhile2(FileInputStream in) throws IOException {
40
        int readData;
41
        // == -1 就结束循环 意味文件里读取完了
42
        while ((readData = in.read()) != -1) {
43
            System.out.println(((char) readData));
44

45
        }
46
    }
47

48
    private static void readWhile1(FileInputStream in) throws IOException {
49
        while (true) {
50
            // read
51
            int readData = in.read();
52
            if (readData == -1) {
53
                break;
54
            }
55
            System.out.println(((char) readData));
56

57
        }
58
    }
59
}

BufferedInputStream缓冲字节输入流#

继承关系

构造方法

BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。默认缓冲区8KB
BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。使用指定的缓冲区

成员方法

3个read

read() 读取单个字节

read(byte [] b) 读取数据填充到数组

read(byte [] b, int off , int len) 读取数据填充到数组

1
package _17io02.com.cskaoyan.bytestream._03buffer;
2

3
import java.io.BufferedInputStream;
4
import java.io.FileInputStream;
5
import java.io.IOException;
6

7
/**
8
 * @description:
9
 * @author: 景天
10
 * @date: 2022/10/17 11:18
11
 **/
12
/*
13
使用缓冲的输入流
14
 */
15
public class Demo3 {
16
    public static void main(String[] args) throws IOException {
17
        // 创建输入流对象
18
        BufferedInputStream in =
19
                new BufferedInputStream(new FileInputStream("a.txt"));
20

21
        // read
22
        // 单个读取
23
        int readData = in.read();
24
        System.out.println(readData);
25

26
        // 批量
27
        byte[] bytes = new byte[1024];
28
        int readCount = in.read(bytes);
29
        System.out.println(new String(bytes,0,readCount));
30

31
        // close
32
        in.close();
33
    }
34
}

文件复制功能#

思路:

读取源文件, 把数据读取到内存里
把内存的数据写到新文件

主要逻辑

使用字节流复制

文本文件: 正常复制

图片文件: 正常复制

视频文件: 正常复制

使用字符流复制

文本文件: 正常复制

图片文件: 复制出错

视频文件: 复制出错

单字节复制还是字节数组方式效率高?

字节数组批量的方式效率高

为什么?

批量的方式会减少跟操作系统的交互

举例:

我在JD 买了5个快递

单字节: 快递小哥1次送一个

字节数组方式: 东哥说了大家都是兄弟配车快递装车里

字符流#

为什么有字符流?#

使用字节流读取英文数字
- 没有问题
使用字节流读取中文
- 可能有问题

一个字符是如何存在计算机中的#

基于某个编码表. 每个字符对应这一个整数值(编码值), 计算机存的就是这个整数值

字符	编码值(整数值)
a	97 ---> 二级制 01100001
你	20320 --->二进制

编码表#

ASCII：美国标准信息交换码。用一个字节的7位可以表示。0000 0000 - 0111 1111 ISO8859-1：拉丁码表。欧洲码表用一个字节的8位表示。 0000 0000 - 1111 1111

GB2312：中国的中文编码表。 GBK：中国的中文编码表升级，融合了更多的中文文字符号。 GB18030：GBK的取代版本 BIG-5码：通行于台湾、香港地区的一个繁体字编码方案，俗称“大五码”。

Unicode：国际标准码，融合了多种文字。

UTF-8：可变长度来表示一个字符。 UTF-8不同，它定义了一种“区间规则”，这种规则可以和ASCII编码保持最大程度的兼容：

它将Unicode编码为00000000-0000007F的字符，用单个字节来表示 0111 1111 = 7F 它将Unicode编码为00000080-000007FF的字符用两个字节表示它将Unicode编码为00000800-0000FFFF的字符用3字节表示

1字节 0xxxxxxx 2字节 110xxxxx 10xxxxxx 3字节 1110xxxx 10xxxxxx 10xxxxxx

utf-16:

jvm使用的编码表，用2个字节来编解码

char : 2 字节

工作中常用的

Ascii 1个字节的低7位
ISO8859-1 1个字节
GBK 2个字节表示一个中文字符
UTF-8 3个字节表示一个中文字符

编解码#

编码

把一字符串数据转为二进制数据存到计算机的过程(把人看懂的东西-----> 计算机看懂的东西)

解码

编码的逆过程(把计算机看懂的东西 ---- > 人看懂的东西)

举例:

类似于摩斯密码

你

中文编码表 0x0001

日文编码表 0x0001 の

默认的编码表

idea: Utf-8
Win: GBK (ANSI 默认的)

java中的编解码#

1
package _17io02.com.cskaoyan.charstream.com.cskoyan._02encode;
2

3
import java.io.UnsupportedEncodingException;
4
import java.util.Arrays;
5

6
/**
7
 * @description:
8
 * @author: 景天
9
 * @date: 2022/10/17 14:58
10
 **/
11
/*
12
java中的编解码
13
 */
14
public class Demo2 {
15
    public static void main(String[] args) throws UnsupportedEncodingException {
16
        // 编码过程
17
        // 人看懂---->计算机看懂的
18
        String s = "你好";
19
        // byte[] getBytes()
20
        // 使用平台的默认字符集将此 String 编码为 byte 序列，
21
        // 并将结果存储到一个新的 byte 数组中
22
        //byte[] bytes = s.getBytes();
23
        //System.out.println(Arrays.toString(bytes));
24
        // [-28, -67, -96, -27, -91, -67]
25

26
        // byte[] getBytes(String charsetName)
27
        // 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
28
        byte[] bytes = s.getBytes("GBK");
29
        System.out.println(Arrays.toString(bytes));
30
        // [-60, -29, -70, -61]
31

32

33
        // 解码过程
34
        // 计算机看懂的----> 人看懂的
35
        // String(byte[] bytes)
36
        // 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
37
        //String s1 = new String(bytes);
38
        //System.out.println(s1);
39

40
        // String(byte[] bytes, String charsetName)
41
        // 通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。
42
        String s2 = new String(bytes, "gbk");
43
        System.out.println(s2);
44

45
    }
46
}

乱码问题

产生的原因: 编码解码不一致
解决: 使其一致

字符流的本质#

字符输出流#

抽象基类Writer#

写入字符流的抽象类

继承关系

成员方法

void	write(char[] cbuf) 写入字符数组。
abstract void	write(char[] cbuf, int off, int len) 写入字符数组的某一部分。
void	write(int c) 写入单个字符。
void	write(String str) 写入字符串。
void	write(String str, int off, int len) 写入字符串的某一部分

具体子类#

OutputStreamWriter转换流#

OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

继承关系

构造方法

OutputStreamWriter(OutputStream out) 创建使用默认字符编码的 OutputStreamWriter。
OutputStreamWriter(OutputStream out, String charsetName) 创建使用指定字符集的 OutputStreamWriter。

成员方法

5个write

3+2

3个跟字符相关的

2个跟字符串相关的

Demo

1
package _17io02.com.cskaoyan.charstream.com.cskoyan._03transfer;
2

3
import java.io.*;
4

5
/**
6
 * @description:
7
 * @author: 景天
8
 * @date: 2022/10/17 15:52
9
 **/
10
/*
11
使用转换输出流写数据
12
 */
13
public class Demo {
14
    public static void main(String[] args) throws IOException {
15
        // 创建输出流对象
16
        //new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(new File("a.txt"))));
17

18
        OutputStreamWriter out =
19
                new OutputStreamWriter(new FileOutputStream("a.txt"));
20

21
        // write
22
        // write(int c) 写单个字符
23
        out.write(97);
24

25
        out.write(System.lineSeparator());
26
        // write(char[] c) 写字符数组
27
        String s = "宝,今天我输液了,什么夜,想你的夜";
28
        char[] chars = s.toCharArray();
29
        out.write(chars);
30

31
        out.write(System.lineSeparator());
32

33
        // write(char[] c, int off ,int len)
34
        out.write(chars, 0, 3);
35

36
        out.write(System.lineSeparator());
37
        // write(String s)
38
        out.write(s);
39

40
        out.write(System.lineSeparator());
41
        // write(String s, int off ,int len)
42
        out.write(s,1,4);
43

44

45
        // flush
46
        out.flush();
47

48
        // close
49
        out.close();
50
    }
51
}

FileWriter简化流#

用来写入字符文件的便捷类

继承关系

构造方法

FileWriter(File file) 根据给定的 File 对象构造一个 FileWriter 对象。
FileWriter(File file, boolean append) 根据给定的 File 对象构造一个 FileWriter 对象。
FileWriter(String fileName) 根据给定的文件名构造一个 FileWriter 对象。
FileWriter(String fileName, boolean append) 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。

成员方法

5个write

3个跟字符相关的

2个跟字符串相关的

1
package _17io02.com.cskaoyan.charstream.com.cskoyan._05simple;
2

3
import java.io.FileWriter;
4
import java.io.IOException;
5

6
/**
7
 * @description:
8
 * @author: 景天
9
 * @date: 2022/10/17 16:32
10
 **/
11
/*
12
使用简化流写数据
13
 */
14
public class Demo2 {
15
    public static void main(String[] args) throws IOException {
16
        // 创建输出流对象
17
        FileWriter fileWriter = new FileWriter("a.txt");
18
        // write
19
        fileWriter.write("宝,我今天拉便便了,什么便,想你的一遍又一遍");
20
        // flush
21
        fileWriter.flush();
22
        // close
23
        fileWriter.close();
24
    }
25
}

BufferedWriter缓冲流#

将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了

继承关系

构造方法

BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。默认缓冲区大小是16KB
BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。缓冲区大小size

成员方法

5 + 1

5个常规的write

1个独有的方法

newLine() 写入一个行分隔符。

Demo

1
package _17io02.com.cskaoyan.charstream.com.cskoyan._06buffer;
2

3
import java.io.BufferedWriter;
4
import java.io.FileOutputStream;
5
import java.io.FileWriter;
6
import java.io.IOException;
7

8
/**
9
 * @description:
10
 * @author: 景天
11
 * @date: 2022/10/17 17:10
12
 **/
13
/*
14
使用缓冲输出流写数据
15
 */
16
public class Demo {
17
    public static void main(String[] args) throws IOException {
18
        // 创建输出流对象
19
        BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
20
        // write
21
        bw.write("大郎,来喝药!");
22

23
        // 独有的方法 newLine
24
        bw.newLine();
25
        bw.write("大郎,来喝药!");
26

27
        // flush
28
        bw.flush();
29

30
        // close
31
        bw.close();
32
    }
33
}

字符输入流#

抽象基类Reader#

用于读取字符流的抽象类

成员方法

int	read() 读取单个字符。作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -1 用readData 读取到的字符值
int	read(char[] cbuf) 将字符读入数组。读取的字符数，如果已到达流的末尾，则返回 -1 用readCount表示读取到的字符的个数
abstract int	read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。

具体子类#

InputStreamReader转换流#

InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

构造方法

InputStreamReader(InputStream in) 创建一个使用默认字符集的 InputStreamReader。
InputStreamReader(InputStream in, String charsetName) 创建使用指定字符集的 InputStreamReader。

成员方法

3个read方法

read()

read(char[] c)

read(char[] c ,int off, int len)

Demo

1
package _17io02.com.cskaoyan.charstream.com.cskoyan._03transfer;
2

3
import java.io.FileInputStream;
4
import java.io.IOException;
5
import java.io.InputStreamReader;
6

7
/**
8
 * @description:
9
 * @author: 景天
10
 * @date: 2022/10/17 16:06
11
 **/
12
/*
13
使用转换流读取数据
14
 */
15
public class Demo2 {
16
    public static void main(String[] args) throws IOException {
17
        // 创建输入流对象
18
        InputStreamReader in = new InputStreamReader(new FileInputStream("a.txt"));
19
        // read
20
        // read() 读取单个字符
21
        int readData = in.read();
22
        System.out.println(((char) readData));
23

24
        // read(char[] c) 批量读取
25
        char[] chars = new char[1024];
26
        int readCount = in.read(chars);
27
        String s = new String(chars, 0, readCount);
28
        System.out.println(s);
29

30
        // close
31
        in.close();
32
    }
33
}

FileReader简化流#

继承关系

构造方法

FileReader(File file) 在给定从中读取数据的 File 的情况下创建一个新 FileReader。
FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader。

成员方法

3个read

Demo

1
package _17io02.com.cskaoyan.charstream.com.cskoyan._05simple;
2

3
import java.io.FileReader;
4
import java.io.IOException;
5

6
/**
7
 * @description:
8
 * @author: 景天
9
 * @date: 2022/10/17 16:37
10
 **/
11
/*
12
简化流读取数据
13
 */
14
public class Demo3 {
15
    public static void main(String[] args) throws IOException {
16
        // 创建输入流对象
17
        FileReader reader = new FileReader("D:\\b.txt");
18
        // read
19
        char[] chars = new char[1024];
20
        int readCount = reader.read(chars);
21
        System.out.println(new String(chars,0,readCount));
22
        // close
23
        reader.close();
24
    }
25
}

转换流VS简化流

使用角度, 简化流简单, 转换流麻烦
继承关系, 转换流是简化流的父类
核心区别, 简化流不能指定字符集(使用默认的字符集), 转化流可以指定的字符集

BufferedReader缓冲流#

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了

继承关系

构造方法

BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz) 创建一个使用指定大小输入缓冲区的缓冲字符输入流。

成员方法

3+1

3个常规read

1个独有的方法

String	readLine() 读取一个文本行。如果已到达流末尾，则返回 null

Demo

1
package _17io02.com.cskaoyan.charstream.com.cskoyan._06buffer;
2

3
import java.io.BufferedReader;
4
import java.io.FileInputStream;
5
import java.io.IOException;
6
import java.io.InputStreamReader;
7

8
/**
9
 * @description:
10
 * @author: 景天
11
 * @date: 2022/10/17 17:17
12
 **/
13

14
/*
15
使用缓冲的输入流读取数据
16
 */
17
public class Demo2 {
18
    public static void main(String[] args) throws IOException {
19
        // 创建输入流对象
20
        BufferedReader br =
21
                new BufferedReader(new InputStreamReader(new FileInputStream("a.txt")));
22
        // 常规read
23
        //char[] chars = new char[1024];
24
        //int readCount = br.read(chars);
25
        //System.out.println(new String(chars, 0, readCount));
26

27
        // 自己独有的方法 readLine()
28
        String s = br.readLine();
29
        System.out.println(s);
30
        String s1 = br.readLine();
31
        System.out.println(s1);
32
        String s2 = br.readLine();
33
        System.out.println(s2);
34
        // close
35
        br.close();
36
    }
37
}
38

39

40

41
package _17io02.com.cskaoyan.charstream.com.cskoyan._06buffer;
42

43
import java.io.BufferedReader;
44
import java.io.FileInputStream;
45
import java.io.IOException;
46
import java.io.InputStreamReader;
47

48
/**
49
 * @description:
50
 * @author: 景天
51
 * @date: 2022/10/17 17:17
52
 **/
53

54
/*
55
使用缓冲的输入流循环读取数据 readline()
56
 */
57
public class Demo3 {
58
    public static void main(String[] args) throws IOException {
59
        // 创建输入流对象
60
        BufferedReader br =
61
                new BufferedReader(new InputStreamReader(new FileInputStream("a.txt")));
62

63
        // 自己独有的方法 readLine()
64
        String line;
65
        while ((line = br.readLine()) != null) {
66
            System.out.println(line);
67
        }
68
        // close
69
        br.close();
70
    }
71
}

其他流#

数据流#

需求: 用字节流向文件中写个整数1000 小数3.14

做不到

DataOutputStream数据输出流#

数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

构造方法

DataOutputStream(OutputStream out) 创建一个新的数据输出流，将数据写入指定基础输出流。

成员方法

每种数据类型都有1个对应的write方法

举例

int ----> writeInt(int a)

double ----> writeDouble(double d)

…

DataInputStream数据输入流#

数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型

构造方法

DataInputStream(InputStream in) 使用指定的底层 InputStream 创建一个 DataInputStream。

成员方法

每种数据类型都有1个对应的read方法

举例

int ----> readInt()

double ----> readDouble()

…

1
package _18io03.com.cskaoyan._01data;
2

3
import java.io.*;
4

5
/**
6
 * @description:
7
 * @author: 景天
8
 * @date: 2022/10/18 10:08
9
 **/
10
/*
11
数据流的使用
12
 */
13
public class Demo2 {
14
    public static void main(String[] args) throws IOException {
15
        writeData();
16
        readData();
17

18
    }
19

20
    private static void readData() throws IOException {
21
        // 创建输入流对象
22
        DataInputStream in = new DataInputStream(new FileInputStream("a.txt"));
23
        // read
24
        int i = in.readInt();
25
        System.out.println(i);
26

27
        double v = in.readDouble();
28
        System.out.println(v);
29
        // close
30
        in.close();
31
    }
32

33
    private static void writeData() throws IOException {
34
        // 创建输出流对象
35
        DataOutputStream out = new DataOutputStream(new FileOutputStream("a.txt"));
36
        // write
37
        // 写1000
38
        out.writeInt(1000);
39
        // 写3.14
40
        out.writeDouble(3.14);
41
        //close
42
        out.close();
43
    }
44
}

1
package _18io03.com.cskaoyan._01data;
2

3
import java.io.*;
4

5
/**
6
 * @description:
7
 * @author: 景天
8
 * @date: 2022/10/18 10:24
9
 **/
10

11
public class Demo3 {
12
    public static void main(String[] args) throws IOException {
13
        write();
14
        read();
15
    }
16

17
    private static void read() throws FileNotFoundException, IOException {
18
        DataInputStream dis = new DataInputStream(
19
                new FileInputStream("dos.txt"));
20
        byte b = dis.readByte();
21
        System.out.println(b);
22
        short s = dis.readShort();
23
        System.out.println(s);
24
        int i = dis.readInt();
25
        System.out.println(i);
26
        long l = dis.readLong();
27
        System.out.println(l);
28
        float f = dis.readFloat();
29
        System.out.println(f);
30
        double d = dis.readDouble();
31
        System.out.println(d);
32
        char ch = dis.readChar();
33
        System.out.println(ch);
34
        boolean bb = dis.readBoolean();
35
        System.out.println(bb);
36
        dis.close();
37
    }
38

39
    private static void write() throws IOException {
40
        DataOutputStream dos = new DataOutputStream(new FileOutputStream(
41
                "dos.txt"));
42
        dos.writeByte(1);
43
        dos.writeShort(20);
44
        dos.writeInt(300);
45
        dos.writeLong(4000);
46
        dos.writeFloat(12.34f);
47
        dos.writeDouble(12.56);
48
        dos.writeChar('a');
49
        dos.writeBoolean(true);
50
        dos.close();
51
    }
52

53
}

注意

写的顺序是什么, 读取的时候要按照相同的顺序
image-20221018102410834

打印流#

核心思想: 把不同的数据类型--->String

案例:

定义一个类Printer

定义成员变量OutputStream

定义5个方法

写int的方法 void printInt(int a)

写int并且换行的方法 void printIntLn(int a)

写double的方法 void printDouble(double a)

写double并且换行的方法 void printDoubleLn(double a)

写一个close方法 void close()

1
package _18io03.com.cskaoyan._02print;
2

3
import java.io.FileOutputStream;
4
import java.io.IOException;
5
import java.io.OutputStream;
6

7
/**
8
 * @description:
9
 * @author: 景天
10
 * @date: 2022/10/18 10:54
11
 **/
12
/*
13
案例:
14

15
定义一个类Printer
16

17
定义成员变量OutputStream
18

19
定义5个方法
20

21
写int的方法  void printInt(int a)
22

23
写int并且换行的方法 void printIntLn(int a)
24

25
写double的方法  void printDouble(double a)
26

27
写double并且换行的方法 void printDoubleLn(double a)
28

29
写一个close方法  void  close()
30
 */
31
public class Demo {
32
    public static void main(String[] args) throws IOException{
33
        // 创建Printer对象 给Out赋值
34
        Printer printer = new Printer(new FileOutputStream("a.txt"));
35
        // 向文件中写1000
36
        printer.printIntLn(1000);
37
        // 3.14
38
        printer.printDouble(3.14);
39
        // close
40
        printer.close();
41
    }
42
}
43

44
class Printer{
45
    // 定义成员变量OutputStream
46
    OutputStream out;
47

48
    public Printer(OutputStream out) {
49
        this.out = out;
50
    }
51

52
    //写int的方法  void printInt(int a)
53
    public void printInt(int a) throws IOException {
54
        // int ---> String
55
        String s = String.valueOf(a);
56
        out.write(s.getBytes());
57
    }
58

59
    //写int并且换行的方法 void printIntLn(int a)
60
    public void printIntLn(int a) throws IOException {
61
        // int ---> String
62
        String s = String.valueOf(a);
63
        out.write(s.getBytes());
64
        out.write(System.lineSeparator().getBytes());
65
    }
66

67
    //写double的方法  void printDouble(double a)
68
    public void printDouble(double a) throws IOException {
69
        // double ---> String
70
        String s = String.valueOf(a);
71
        out.write(s.getBytes());
72
    }
73

74
    //写double并且换行的方法 void printDoubleLn(double a)
75
    public void printDoubleLn(double a) throws IOException {
76
        // double ---> String
77
        String s = String.valueOf(a);
78
        out.write(s.getBytes());
79
        out.write(System.lineSeparator().getBytes());
80

81
    }
82

83
    //写一个close方法  void  close()
84
    public void close() throws IOException {
85
        out.close();
86
    }
87
}

PrintStream字节打印流#

PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式

继承关系

构造方法

PrintStream(File file) 创建具有指定文件且不带自动行刷新的新打印流。
PrintStream(OutputStream out) 创建新的打印流。
PrintStream(OutputStream out, boolean autoFlush) 创建新的打印流。
PrintStream(String fileName) 创建具有指定文件名称且不带自动行刷新的新打印流。

成员方法

每个数据类型都有一个相对应的print方法(print方法的重载)

举例:

int ---> print(int a)

double ---> print(double d)

…

1
package _18io03.com.cskaoyan._02print;
2

3
import java.io.IOException;
4
import java.io.PrintStream;
5

6
/**
7
 * @description:
8
 * @author: 景天
9
 * @date: 2022/10/18 11:09
10
 **/
11
/*
12
使用字节打印流写数据
13
 */
14
public class Demo2 {
15
    public static void main(String[] args) throws IOException {
16
        // 创建输出流对象
17
        PrintStream printStream = new PrintStream("a.txt");
18
        // print
19
        // 写int 1000
20
        printStream.print(1000);
21
        // 写true
22
        printStream.print(true);
23
        // close
24
        printStream.close();
25
    }
26
}

PrintWriter字符打印流#

向文本输出流打印对象的格式化表示形式

继承关系

构造方法

PrintWriter(File file) 使用指定文件创建不具有自动行刷新的新 PrintWriter。
PrintWriter(OutputStream out) 根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。
PrintWriter(OutputStream out, boolean autoFlush) 通过现有的 OutputStream 创建新的 PrintWriter。
PrintWriter(String fileName) 创建具有指定文件名称且不带自动行刷新的新 PrintWriter。
PrintWriter(Writer out) 创建不带自动行刷新的新 PrintWriter。
PrintWriter(Writer out, boolean autoFlush) 创建新 PrintWriter。

成员方法

每个数据类型都有一个相对应的print方法

举例:

int ---> print(int a)

double ---> print(double d)

…

Demo

1
package _18io03.com.cskaoyan._02print;
2

3
import java.io.FileWriter;
4
import java.io.IOException;
5
import java.io.PrintStream;
6
import java.io.PrintWriter;
7

8
/**
9
 * @description:
10
 * @author: 景天
11
 * @date: 2022/10/18 11:09
12
 **/
13
/*
14
使用字符打印流写数据
15
 */
16
public class Demo3 {
17
    public static void main(String[] args) throws IOException {
18
        // 创建输出流对象
19
        PrintWriter printWriter = new PrintWriter(new FileWriter("a.txt"));
20
        // print
21
        // 写int 1000
22
        printWriter.print(1000);
23
        // 写true
24
        printWriter.print(true);
25
        // flush
26
        printWriter.flush();
27
        // close
28
        printWriter.close();
29
    }
30
}

打印流特点

只能操作目的地，不能操作数据来源。
- 没有与之相对应的输入流
可以操作任意类型的数据。
- 把任意类型的数据--->String (String.valueOf(不同类型的数据))
如果启动了自动刷新，能够自动刷新。
- autoFlush如果为 true，则 println、printf 或 format 方法将刷新输出缓冲区
- image-20221018112240762
- image-20221018112318534
可以操作文件的流
- 构造方法里可以传File对象或者String fileName

标准输入输出流#

标准输入流

System.in
默认输入设备是键盘
本质: InputStream 普通的字节输入流

标准输出流

System.out
默认输出设备显示器
本质: PrintStream 字节打印流

练习：利用System.in 完成Scanner的nextLine()的功能。

想到BufferedReader 有个readLine

1
package _18io03.com.cskaoyan._03stander;
2

3
import java.io.BufferedReader;
4
import java.io.IOException;
5
import java.io.InputStreamReader;
6

7
/**
8
 * @description:
9
 * @author: 景天
10
 * @date: 2022/10/18 11:34
11
 **/
12
/*
13
练习：利用System.in 完成Scanner的nextLine()的功能。
14

15
System.in 本质InputStream
16
 */
17
public class Demo3 {
18
    public static void main(String[] args) throws IOException {
19
        // 创建BufferedReader对象
20
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
21
        // 调用readLine方法
22
        // 更改需求 要求能多次输入
23
        String line;
24
        // 通过约定标记结束 比如输入gun 结束
25
        while ((line = br.readLine()) != null) {
26
            System.out.println("line = " + line);
27
            if ("gun".equals(line)) {
28
                break;
29
            }
30
        }
31

32
        // close
33
        br.close();
34
    }
35
}

对象流(序列化与反序列化流)#

什么是序列化与反序列化?

序列化: 把对象数据转为二进制数据, 存到文件的过程
反序列:(序列化的逆过程) 把二进制数据还原回对象数据的过程

为什么需要序列化?

把对象持久化保存

1
Student s = new Student("zs",20);

ObjectOutputStream序列化流#

ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取（重构）对象。通过在流中使用文件可以实现对象的持久存储。如果流是网络套接字流，则可以在另一台主机上或另一个进程中重构对象。

只能将支持 java.io.Serializable 接口的对象写入流中 Serializable接口是一个空接口, 起到标记的作用

writeObject 方法用于将对象写入流中

继承关系

构造方法

ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream。

成员方法

void	writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。

ObjectInputStream反序列化流#

ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化

继承关系

构造方法

ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的 ObjectInputStream。

成员方法

Object	readObject() 从 ObjectInputStream 读取对象。

1
package _18io03.com.cskaoyan._04serialize;
2

3
import java.io.*;
4

5
/**
6
 * @description:
7
 * @author: 景天
8
 * @date: 2022/10/18 14:30
9
 **/
10

11
public class Demo {
12
    public static void main(String[] args) throws IOException, ClassNotFoundException {
13
        serialize();
14

15

16
        unSerialize();
17

18

19
    }
20

21
    private static void unSerialize() throws IOException, ClassNotFoundException {
22
        // 创建输入流对象
23
        ObjectInputStream in =
24
                new ObjectInputStream(new FileInputStream("a.txt"));
25
        // readObject()
26
        Object o = in.readObject();
27
        System.out.println(o);
28
        // close
29
        in.close();
30
    }
31

32
    private static void serialize() throws IOException {
33
        // 创建学生对象
34
        Student student = new Student("ls", 21,59);
35
        // 创建输出流对象
36
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("a.txt"));
37
        // writeObject(Object o)
38
        out.writeObject(student);
39
        // close
40
        out.close();
41
    }
42
}
43

44
class Student implements Serializable {
45
    String name;
46
    int age;
47
    // transient修饰不想被序列化的成员变量
48
    transient int score;
49
    static final long serialVersionUID = -7889256375299507710L;
50

51

52
    public Student(String name, int age) {
53
        this.name = name;
54
        this.age = age;
55
    }
56

57
    public Student(String name, int age, int score) {
58
        this.name = name;
59
        this.age = age;
60
        this.score = score;
61
    }
62

63
    @Override
64
    public String toString() {
65
        return "Student{" +
66
                "name='" + name + '\'' +
67
                ", age=" + age +
68
                ", score=" + score +
69
                '}';
70
    }
71
}

设置自动生成SeriaversionUID

注意

java.io.NotSerializableException 没有实现Serializable接口
java.io.InvalidClassException: _18io03.com.cskaoyan._04serialize.Student; local class incompatible: stream classdesc serialVersionUID = -7889256375299507710, local class serialVersionUID = 7388140007375758175 SerialVersionUID不匹配
transient修饰不想被序列化的成员变量

总结#

类型	字节输出流	字节输入流	字符输出流	字符输入流
抽象基类	OutputStream	InputStream	Writer	Reader
文件相关	FileOutputStream	FileInputStream	FileWriter	FileReader
缓冲相关	BufferedOutputStream	BufferedInputStream	BufferedWriter	BufferedReader
转换相关			OutputStreamWriter	InputStreamReader
数据相关	DataOutputStream	DataInputStream
打印相关	PrintStream		PrintWriter
对象相关	ObjectOutpuStream	ObjectInputStream

Java 基础语法：IO 流

IO概述#

什么是IO?#

为什么有IO?#

java中如何实现IO功能#

IO的分类#

4个抽象基类#

什么时候用什么流?#

字节流#

字节输出流#

抽象基类OutputStream#

具体子类#

FileOutputStream文件字节输出流#

注意事项#

BufferedOutputStream缓冲字节输出流#

字节输入流#

抽象基类InputStream#

具体子类#

FileInputStream文件字节输入流#

BufferedInputStream缓冲字节输入流#

文件复制功能#

字符流#

为什么有字符流?#

一个字符是如何存在计算机中的#

编码表#

编解码#

java中的编解码#

字符流的本质#

字符输出流#

抽象基类Writer#

具体子类#

OutputStreamWriter转换流#

FileWriter简化流#

BufferedWriter缓冲流#

字符输入流#

抽象基类Reader#

具体子类#

InputStreamReader转换流#

FileReader简化流#

BufferedReader缓冲流#

其他流#

数据流#

DataOutputStream数据输出流#

DataInputStream数据输入流#

打印流#

PrintStream字节打印流#

PrintWriter字符打印流#

标准输入输出流#

对象流(序列化与反序列化流)#

ObjectOutputStream序列化流#

ObjectInputStream反序列化流#

总结#

文章分享

文章目录