4 - IO

先进先出：最先写入输出流的数据最先被输入流读取到。
顺序存取：可以一个接一个地往流中写入一串字节，读出时也将按写入顺序读取一串字节，不能随机访问中间的数据。（RandomAccessFile除外）
只读或只写：每个流只能是输入流或输出流的一种，不能同时具备两个功能，输入流只能进行读操作，对输出流只能进行写操作。在一个数据传输通道中，如果既要写入数据，又要读取数据，则要分别提供两个流。

1.1 传输方式划分

传输方式有两种，字节和字符

字节（byte）是计算机中用来表示存储容量的一个计量单位，一个字节有 8 位（bit）
字符（char）可以是计算机中使用的字母、数字、和符号（通常来说，一个字母或者一个字符占用一个字节，一个汉字占用两个字节）

具体还要看字符编码，比如说在 UTF-8 编码下，一个英文字母（不分大小写）为一个字节，一个中文汉字为三个字节；在 Unicode 编码中，一个英文字母为一个字节，一个中文汉字为两个字节

字节流和字符流的区别：

字节流一般用来处理图像、视频、音频、PPT、Word等类型的文件。字符流一般用于处理纯文本类型的文件，如TXT文件等，但不能处理图像视频等非文本文件
字节流本身没有缓冲区，缓冲字节流相对于字节流，效率提升非常高。而字符流本身就带有缓冲区，缓冲字符流相对于字符流效率提升就不是那么大

1）InputStream 类

int read(): 读取数据
int read(byte b[], int off, int len)：从第 off 位置开始读，读取 len 长度的字节，然后放入数组b
long skip(long n)：跳过指定个数的字节
int available()：返回可读的字节数
void close()：关闭流，释放资源

2）OutputStream 类

void write(int b)：写入一个字节，虽然参数是一个 int，但只有低8位才会写入，高24位舍弃
void?read(byte b[], int off, int len)：将数组 b 中的从 off 位置开始，长度为 len 的字节写入
void flush()：?强制刷新，将缓冲区的数据写入
void close()：关闭流

3）Reader类

int read()：读取单个字符
int read(char cbuf[], int off, int len)：从第 off 位置开始读，读取 len 长度的字符，然后放入b
long skip(long n)：跳过指定个数的字符
int ready()：是否可以读了
void close()：关闭流，释放资源

4）Writer 类

void writer(int c)：写入一个字符
void write(char cbuf[], int off, int len)：将数组cbuf中的从 off 位置开始，长度为 len 字符写入
void flush()：?强制刷新，将缓冲区的数据写入
void close()：关闭流

1.2 操作对象划分

Input：将外部的数据读入内存，比如把文件从硬盘读取到内存，从网络读取数据到内存
Output：将内存中的数据写入到外部，比如把数据从内存写入到文件，数据从内存输出到网络

?1）文件

文件流也就是直接操作文件的流，可以细分为字节流（FileInputStream 和 FileOuputStream）和字符流（FileReader 和 FileWriter）

FileInputStream 的例子：

// 声明一个 int 类型的变量 b，用于存储读取到的字节
int b;
// 创建一个 FileInputStream 对象，用于读取文件 fis.txt 中的数据
FileInputStream fis1 = new FileInputStream("fis.txt");

// 循环读取文件中的数据
while ((b = fis1.read()) != -1) {
    // 将读取到的字节转换为对应的 ASCII 字符，并输出到控制台
    System.out.println((char)b);
}
// 关闭 FileInputStream 对象，释放资源
fis1.close();

FileOutputStream 的例子：

// 创建一个 FileOutputStream 对象，用于写入数据到文件 fos.txt 中
FileOutputStream fos = new FileOutputStream("fos.txt");

// 向文件中写入数据，这里写入的是字符串 "沉默王二" 对应的字节数组
fos.write("沉默王二".getBytes());

// 关闭 FileOutputStream 对象，释放资源
fos.close();

FileReader 的例子：

// 声明一个 int 类型的变量 b，用于存储读取到的字符
int b = 0;

// 创建一个 FileReader 对象，用于读取文件 read.txt 中的数据
FileReader fileReader = new FileReader("read.txt");

// 循环读取文件中的数据
while ((b = fileReader.read()) != -1) {
    // 将读取到的字符强制转换为 char 类型，并输出到控制台
    System.out.println((char)b);
}

// 关闭 FileReader 对象，释放资源
fileReader.close();

FileWriter 的例子：

// 创建一个 FileWriter 对象，用于写入数据到文件 fw.txt 中
FileWriter fileWriter = new FileWriter("fw.txt");

// 将字符串 "沉默王二" 转换为字符数组
char[] chars = "沉默王二".toCharArray();

// 向文件中写入数据，这里写入的是 chars 数组中的所有字符
fileWriter.write(chars, 0, chars.length);

// 关闭 FileWriter 对象，释放资源
fileWriter.close();

文件流还可以用于创建、删除、重命名文件等操作。FileOutputStream 和 FileWriter 构造函数的第二个参数可以指定是否追加数据到文件末尾

// 创建文件
File file = new File("test.txt");
if (file.createNewFile()) {
    System.out.println("文件创建成功");
} else {
    System.out.println("文件已存在");
}

// 删除文件
if (file.delete()) {
    System.out.println("文件删除成功");
} else {
    System.out.println("文件删除失败");
}

// 重命名文件
File oldFile = new File("old.txt");
File newFile = new File("new.txt");
if (oldFile.renameTo(newFile)) {
    System.out.println("文件重命名成功");
} else {
    System.out.println("文件重命名失败");
}

2）数组（内存）

针对文件的读写操作，使用文件流配合缓冲流就够用了，但为了提升效率，频繁地读写文件并不是太好，那么就出现了数组流，有时候也称为内存流

ByteArrayInputStream 的例子：

// 创建一个 ByteArrayInputStream 对象，用于从字节数组中读取数据
InputStream is = new BufferedInputStream(
        new ByteArrayInputStream(
                "沉默王二".getBytes(StandardCharsets.UTF_8)));

// 定义一个字节数组用于存储读取到的数据
byte[] flush = new byte[1024];

// 定义一个变量用于存储每次读取到的字节数
int len = 0;

// 循环读取字节数组中的数据，并输出到控制台
while (-1 != (len = is.read(flush))) {
    // 将读取到的字节转换为对应的字符串，并输出到控制台
    System.out.println(new String(flush, 0, len));
}

// 关闭输入流，释放资源
is.close();

ByteArrayOutputStream 的例子：

// 创建一个 ByteArrayOutputStream 对象，用于写入数据到内存缓冲区中
ByteArrayOutputStream bos = new ByteArrayOutputStream();

// 定义一个字节数组用于存储要写入内存缓冲区中的数据
byte[] info = "输入输出".getBytes();

// 向内存缓冲区中写入数据，这里写入的是 info 数组中的所有字节
bos.write(info, 0, info.length);

// 将内存缓冲区中的数据转换为字节数组
byte[] dest = bos.toByteArray();

// 关闭 ByteArrayOutputStream 对象，释放资源
bos.close();

数组流可以用于在内存中读写数据，比如将数据存储在字节数组中进行压缩、加密、序列化等

优点：不需要创建临时文件，可以提高程序的效率

缺点：只能存储有限的数据量，如果存储的数据量过大，会导致内存溢出

3）管道

在 Unix/Linux 中，不同的进程之间可以通过管道来通信。java 中则是通信的双方必须在同一个进程中，管道为线程之间的通信提供了通信能力

一个线程通过 PipedOutputStream 写入的数据可以被另外一个线程通过相关联的 PipedInputStream 读取出

// 创建一个 PipedOutputStream 对象和一个 PipedInputStream 对象
final PipedOutputStream pipedOutputStream = new PipedOutputStream();
final PipedInputStream pipedInputStream = new PipedInputStream(pipedOutputStream);

// 创建一个线程，向 PipedOutputStream 中写入数据
Thread thread1 = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            // 将字符串 "输入输出" 转换为字节数组，并写入到 PipedOutputStream 中
            pipedOutputStream.write("输入输出".getBytes(StandardCharsets.UTF_8));
            // 关闭 PipedOutputStream，释放资源
            pipedOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
});

// 创建一个线程，从 PipedInputStream 中读取数据并输出到控制台
Thread thread2 = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            // 定义一个字节数组用于存储读取到的数据
            byte[] flush = new byte[1024];
            // 定义一个变量用于存储每次读取到的字节数
            int len = 0;
            // 循环读取字节数组中的数据，并输出到控制台
            while (-1 != (len = pipedInputStream.read(flush))) {
                // 将读取到的字节转换为对应的字符串，并输出到控制台
                System.out.println(new String(flush, 0, len));
            }
            // 关闭 PipedInputStream，释放资源
            pipedInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
});

// 启动线程1和线程2
thread1.start();
thread2.start();

使用管道流可以实现不同线程之间的数据传输，可以用于线程间的通信、数据的传递等

管道的局限性：只能在同一个 JVM 中的线程之间使用，不能跨越不同的 JVM 进程

4）基本数据类型

基本数据类型输入输出流是一个字节流，该流不仅可以读写字节和字符，还可以读写基本数据类型

DataInputStream 例子：

// 创建一个 DataInputStream 对象，用于从文件中读取数据
DataInputStream dis = new DataInputStream(new FileInputStream("das.txt"));

// 读取一个字节，将其转换为 byte 类型
byte b = dis.readByte();

// 读取两个字节，将其转换为 short 类型
short s = dis.readShort();

// 读取四个字节，将其转换为 int 类型
int i = dis.readInt();

// 读取八个字节，将其转换为 long 类型
long l = dis.readLong();

// 读取四个字节，将其转换为 float 类型
float f = dis.readFloat();

// 读取八个字节，将其转换为 double 类型
double d = dis.readDouble();

// 读取一个字节，将其转换为 boolean 类型
boolean bb = dis.readBoolean();

// 读取两个字节，将其转换为 char 类型
char ch = dis.readChar();

// 关闭 DataInputStream，释放资源
dis.close();

DataOutputStream 例子：

// 创建一个 DataOutputStream 对象，用于将数据写入到文件中
DataOutputStream das = new DataOutputStream(new FileOutputStream("das.txt"));

// 将一个 byte 类型的数据写入到文件中
das.writeByte(10);

// 将一个 short 类型的数据写入到文件中
das.writeShort(100);

// 将一个 int 类型的数据写入到文件中
das.writeInt(1000);

// 将一个 long 类型的数据写入到文件中
das.writeLong(10000L);

// 将一个 float 类型的数据写入到文件中
das.writeFloat(12.34F);

// 将一个 double 类型的数据写入到文件中
das.writeDouble(12.56);

// 将一个 boolean 类型的数据写入到文件中
das.writeBoolean(true);

// 将一个 char 类型的数据写入到文件中
das.writeChar('A');

// 关闭 DataOutputStream，释放资源
das.close();

ObjectInputStream 和 ObjectOutputStream（用于读写对象）

创建了一个 Person 对象，将其写入文件中，然后从文件中读取该对象，并打印在控制台上

public static void main(String[] args) {
    try (ObjectOutputStream oos = new ObjectOutputStream(new 
        FileOutputStream("person.dat"))) {
        Person p = new Person("张三", 20);
        oos.writeObject(p);
    } catch (IOException e) {
        e.printStackTrace();
    }

    try (ObjectInputStream ois = new 
        ObjectInputStream(new FileInputStream("person.dat"))) {
        Person p = (Person) ois.readObject();
        System.out.println(p);
    } catch (IOException | ClassNotFoundException e) {
        e.printStackTrace();
    }
}

5）缓冲

为了减少程序和硬盘的交互，提升程序的效率，就引入了缓冲流，也就是类名前缀带有 Buffer 的

例如：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter

BufferedInputStream 读取文件的示例：

创建了一个 BufferedInputStream 对象，用于从文件中读取数据
创建了一个字节数组作为缓存区
通过 while 循环实现读取数据
每次读取数据后对缓存区中的数据进行处理
关闭 BufferedInputStream，释放资源

// 创建一个 BufferedInputStream 对象，用于从文件中读取数据
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("data.txt"));

// 创建一个字节数组，作为缓存区
byte[] buffer = new byte[1024];

// 读取文件中的数据，并将其存储到缓存区中
int bytesRead;
while ((bytesRead = bis.read(buffer)) != -1) {
    // 对缓存区中的数据进行处理
    // 这里只是简单地将读取到的字节数组转换为字符串并打印出来
    System.out.println(new String(buffer, 0, bytesRead));
}

// 关闭 BufferedInputStream，释放资源
bis.close();

使用 BufferedOutputStream 写入文件的示例：

创建了一个 BufferedOutputStream 对象，用于将数据写入到文件中
创建了一个字节数组作为缓存区
通过 write() 方法实现写入数据
通过 flush() 方法将缓存区中的数据写入到文件中
关闭，释放资源

注：写入数据时，由于使用了 BufferedOutputStream，数据会先被写入到缓存区中，只有在缓存区被填满或者调用了 flush() 方法时才会将缓存区中的数据写入到文件中

// 创建一个 BufferedOutputStream 对象，用于将数据写入到文件中
BufferedOutputStream bos = 
    new BufferedOutputStream(new FileOutputStream("data.txt"));

// 创建一个字节数组，作为缓存区
byte[] buffer = new byte[1024];

// 将数据写入到文件中
String data = "沉默王二是个大傻子!";
buffer = data.getBytes();
bos.write(buffer);

// 刷新缓存区，将缓存区中的数据写入到文件中
bos.flush();

// 关闭 BufferedOutputStream，释放资源
bos.close();

使用 BufferedReader 读取文件的示例：

创建了一个 BufferedReader 对象，用于从文件中读取数据
使用 readLine() 方法读取文件中的数据
每次读取一行数据并将其存储到一个字符串中
关闭，释放资源

// 创建一个 BufferedReader 对象，用于从文件中读取数据
BufferedReader br = new BufferedReader(new FileReader("data.txt"));

// 读取文件中的数据，并将其存储到字符串中
String line;
while ((line = br.readLine()) != null) {
    // 对读取到的数据进行处理
    // 这里只是简单地将读取到的每一行字符串打印出来
    System.out.println(line);
}

// 关闭 BufferedReader，释放资源
br.close();

使用 BufferedWriter 写入文件的示例：

创建了一个 BufferedWriter 对象，用于将数据写入到文件中
使用 write() 方法将数据写入到缓存区中（和使用 FileWriter 类似）
通过 flush() 方法将缓存区中的数据写入到文件中
close() 方法关闭 BufferedWriter，释放资源

// 创建一个 BufferedWriter 对象，用于将数据写入到文件中
BufferedWriter bw = new BufferedWriter(new FileWriter("data.txt"));

// 将数据写入到文件中
String data = "输入输出";
bw.write(data);

// 刷新缓存区，将缓存区中的数据写入到文件中
bw.flush();

// 关闭 BufferedWriter，释放资源
bw.close();

缓冲

优点：可以提高读写效率，减少了频繁的读写磁盘或网络的次数，从而提高了程序的性能

缺点：需要注意缓冲区的大小和清空缓冲区的时机，以避免数据丢失或不完整的问题

6）打印?

打印输出数据的类包括 PrintStream 和 PrintWriter 两个类

PrintStream 最终输出的是字节数据，而 PrintWriter 则是扩展了 Writer 接口，所以它的?print()/println()?方法最终输出的是字符数据。使用上几乎和 PrintStream 一模一样

StringWriter buffer = new StringWriter();
try (PrintWriter pw = new PrintWriter(buffer)) {
    pw.println("输入输出");
}
System.out.println(buffer.toString());

7）对象序列化/反序列化

序列化本质上是将一个 Java 对象转成字节数组，然后可以将其保存到文件中，或者通过网络传输到远程

创建一个 ByteArrayOutputStream 对象 buffer，用于存储数据
try-with-resources?创建一个 ObjectOutputStream 对象 output，并将其与 buffer 关联
使用 writeUTF() 方法将字符串写入到缓冲区中
try-with-resources 语句执行完毕时，会自动调用 output 的 close() 方法关闭输出流，释放资源
使用 toByteArray() 方法将缓冲区中的数据转换成字节数组
使用 Arrays.toString() 方法将字节数组转换成字符串，并输出到控制台

// 创建一个 ByteArrayOutputStream 对象 buffer，用于存储数据
ByteArrayOutputStream buffer = new ByteArrayOutputStream();

// 使用 try-with-resources 语句创建一个 ObjectOutputStream 对象 output
// 并将其与 buffer 关联
try (ObjectOutputStream output = new ObjectOutputStream(buffer)) {
    
    // 使用 writeUTF() 方法将字符串 "输入输出" 写入到缓冲区中
    output.writeUTF("输入输出");
}

// 使用 toByteArray() 方法将缓冲区中的数据转换成字节数组，并输出到控制台
System.out.println(Arrays.toString(buffer.toByteArray()));

反序列化，也就是再将字节数组转成 Java 对象的过程

try (ObjectInputStream input = new ObjectInputStream(new FileInputStream(
        new File("Person.txt")))) {
    String s = input.readUTF();
}

8）转换

InputStreamReader 是从字节流到字符流的桥连接，它使用指定的字符集读取字节并将它们解码为字符

// 创建一个 InputStreamReader 对象 isr
// 使用 FileInputStream 对象读取文件 demo.txt 的内容并将其转换为字符流
InputStreamReader isr = new InputStreamReader(new FileInputStream("demo.txt"));

// 创建一个字符数组 cha，用于存储读取的字符数据，其中 1024 表示数组的长度
char[] cha = new char[1024];

// 使用 read() 方法读取 isr 中的数据，并将读取的字符数据存储到 cha 数组中
// 返回值 len 表示读取的字符数
int len = isr.read(cha);

// 将 cha 数组中从下标 0 开始、长度为 len 的部分转换成字符串，并输出到控制台
System.out.println(new String(cha, 0, len));

// 关闭 InputStreamReader 对象 isr，释放资源
isr.close();

OutputStreamWriter 将字符流的输出对象变为字节流的输出对象，是字符流通向字节流的桥梁

// 创建一个 File 对象 f，表示文件 test.txt
File f = new File("test.txt");

// 创建一个 OutputStreamWriter 对象 out，
// 使用 FileOutputStream 对象将数据写入到文件 f 中，并将字节流转换成字符流
Writer out = new OutputStreamWriter(new FileOutputStream(f));

// 使用 write() 方法将字符串 "输入输出!!" 写入到文件 f 中
out.write("输入输出!!");

// 关闭 Writer 对象 out，释放资源
out.close();

在进行文本文件读写时，通常使用字符流进行操作，而在进行网络传输或与设备进行通信时，通常使用字节流进行操作

?注：在使用转换流时需要注意字符编码的问题。如果不指定字符编码，则使用默认的字符编码，可能会出现乱码问题

2. 文件流 Java File

File 跟流无关，File 类不能对文件进行读和写

2.1 File 构造

// 文件路径名
String path = "/Users/username/123.txt";
File file1 = new File(path); -------相当于/Users/username/123.txt
// 文件路径名
String path2 = "/Users/username/1/2.txt";
File file2 = new File(path2); -------相当于/Users/username/1/2.txt
// 通过父路径和子路径字符串
String parent = "/Users/username/aaa";
String child = "bbb.txt";
File file3 = new File(parent, child); ------相当于/Users/username/aaa/bbb.txt
// 通过父级File对象和子路径字符串
File parentDir = new File("/Users/username/aaa");
String child = "bbb.txt";
File file4 = new File(parentDir, child); ----相当于/Users/username/aaa/bbb.txt

注：

macOS 与 Linux 路径使用正斜杠 / 作为路径分隔符，而 Windows 路径使用反斜杠作 \ 为路径分隔符，使用 File.separator ，这个属性会根据操作系统自动返回正确的路径分隔符
File 类的构造方法不会检验这个文件或目录是否真实存在，因此无论该路径下是否存在文件或者目录，都不影响 File 对象的创建

2.2 常用方法

1）获取功能的方法

File f = new File("/Users/username/aaa/bbb.java");
System.out.println("文件绝对路径:"+f.getAbsolutePath());
System.out.println("文件构造路径:"+f.getPath());
System.out.println("文件名称:"+f.getName());
System.out.println("文件长度:"+f.length()+"字节");

File f2 = new File("/Users/username/aaa");
System.out.println("目录绝对路径:"+f2.getAbsolutePath());
System.out.println("目录构造路径:"+f2.getPath());
System.out.println("目录名称:"+f2.getName());
System.out.println("目录长度:"+f2.length());

注：length() 表示文件的长度，File 对象表示目录的时候毫无意义

2）绝对路径与相对路径

绝对路径是从文件系统的根目录开始的完整路径

相对路径是相对于当前工作目录的路径

注：Windows 文件系统默认是不区分大小写，Unix 系统中默认是区分大小写的

3）判断功能的方法

File file = new File("/Users/username/example");

// 判断文件或目录是否存在
if (file.exists()) {
    System.out.println("文件或目录存在");
} else {
    System.out.println("文件或目录不存在");
}

// 判断是否是目录
if (file.isDirectory()) {
    System.out.println("是目录");
} else {
    System.out.println("不是目录");
}

// 判断是否是文件
if (file.isFile()) {
    System.out.println("是文件");
} else {
    System.out.println("不是文件");
}

4）创建，删除方法

createNewFile()：文件不存在，创建一个新的空文件并返回 true，文件存在则返回 false
delete()：删除文件或目录。如果是目录，只有目录为空才能删除
mkdir()：只能创建一级目录，如果父目录不存在，则创建失败
mkdirs()：可以创建多级目录，如果父目录不存在，则会一并创建（开发中常用）

// 创建文件
File file = new File("/Users/username/example/test.txt");
if (file.createNewFile()) {
    System.out.println("创建文件成功：" + file.getAbsolutePath());
} else {
    System.out.println("创建文件失败：" + file.getAbsolutePath());
}

// 删除文件
if (file.delete()) {
    System.out.println("删除文件成功：" + file.getAbsolutePath());
} else {
    System.out.println("删除文件失败：" + file.getAbsolutePath());
}

// 创建多级目录
File directory = new File("/Users/username/example/subdir1/subdir2");
if (directory.mkdirs()) {
    System.out.println("创建目录成功：" + directory.getAbsolutePath());
} else {
    System.out.println("创建目录失败：" + directory.getAbsolutePath());
}

5）目录遍历

String[ ] list()：返回一个 String 数组，表示该 File 目录中的所有子文件或目录
File[ ] listFiles()：返回一个 File 数组，表示该 File 目录中的所有的子文件或目录

File directory = new File("/Users/Documents/Github");

// 列出目录下的文件名
String[] files = directory.list();
System.out.println("目录下的文件名：");
for (String file : files) {
    System.out.println(file);
}

// 列出目录下的文件和子目录
File[] filesAndDirs = directory.listFiles();
System.out.println("目录下的文件和子目录：");
for (File fileOrDir : filesAndDirs) {
    if (fileOrDir.isFile()) {
        System.out.println("文件：" + fileOrDir.getName());
    } else if (fileOrDir.isDirectory()) {
        System.out.println("目录：" + fileOrDir.getName());
    }
}

注：listFiles?必须满足下面两个条件

指定的目录必须存在
指定必须是目录，否则引发 NullPointException 异常

6）递归遍历?

public static void main(String[] args) {
    File directory = new File("/Users/Documents/Github");

    // 递归遍历目录下的文件和子目录
    traverseDirectory(directory);
}

public static void traverseDirectory(File directory) {
    // 列出目录下的所有文件和子目录
    File[] filesAndDirs = directory.listFiles();

    // 遍历每个文件和子目录
    for (File fileOrDir : filesAndDirs) {
        if (fileOrDir.isFile()) {
            // 如果是文件，输出文件名
            System.out.println("文件：" + fileOrDir.getName());
        } else if (fileOrDir.isDirectory()) {
            // 如果是目录，递归遍历子目录
            System.out.println("目录：" + fileOrDir.getName());
            traverseDirectory(fileOrDir);
        }
    }
}

2.2 RandomAccessFile

RandomAccessFile?既可以用来读取文件，也可以用来写入文件

不同之处：允许跳转到文件的任何位置，从那里开始读取或写入，特别适用于需要在文件中随机访问数据的场景，如数据库系统

import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessFileDemo {

    public static void main(String[] args) {
        String filePath = "logs/test.txt";

        try {
            // 使用 RandomAccessFile 写入文件
            writeToFile(filePath, "Hello, world!");

            // 使用 RandomAccessFile 读取文件
            String content = readFromFile(filePath);
            System.out.println("文件内容: " + content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void writeToFile(String filePath, String content) throws IOException {
        try (RandomAccessFile randomAccessFile = new RandomAccessFile(filePath, "rw")) {
            // 将文件指针移动到文件末尾（在此处追加内容）
            randomAccessFile.seek(randomAccessFile.length());
            // 写入内容
            randomAccessFile.writeUTF(content);
        }
    }

    private static String readFromFile(String filePath) throws IOException {
        StringBuilder content = new StringBuilder();

        try (RandomAccessFile randomAccessFile = new RandomAccessFile(filePath, "r")) {
            // 将文件指针移动到文件开始处（从头开始读取）
            randomAccessFile.seek(0);

            content.append(randomAccessFile.readUTF());
        }
        return content.toString();
    }
}

为了避免中文乱码问题，我们使用 RandomAccessFile 的 writeUTF 和 readUTF 方法，它们将使用 UTF-8 编码处理字符串

1）构造方法

RandomAccessFile(File file, String mode)：使用给定的文件对象和访问模式
RandomAccessFile(String name, String mode)：使用给定的文件名和访问模式

访问模式 mode 的值可以是：

"r"：以只读模式打开文件，使用了写操作会导致 IOExpection
"rw"：以读写模式打开文件。如果文件不存在，它将被创建
"rws"：以读写模式打开文件，并要求对内容或元数据的每个更新都被立即写入到底层存储设备。这种模式是同步的，可以确保在系统崩溃时不会丢失数据
"rwd"：与“rws”类似，以读写模式打开文件，但仅要求对文件内容的更新被立即写入。元数据可能会被延迟写入

2）主要方法

long getFilePointer()：返回文件指针的当前位置
long length()：返回此文件的长度
int read()：从该文件中读取一个字节数据
int read(byte[ ] b)：从该文件中读取字节数据并将其存储到指定的字节数组中
int read(byte[ ] b, int off, int len)：从该文件中读取字节数据并将其存储到指定的字节数组中，从偏移量 off 开始，最多读取 len 个字节
String readLine()：从该文件中读取一行文本
readUTF()：从文件读取 UTF-8 编码的字符串
void seek(long pos)：将文件指针设置到文件中的 pos 位置
void write(byte[] b)：将指定的字节数组的所有字节写入该文件
void write(byte[ ] b, int off, int len)：将指定字节数组的部分字节写入该文件，从偏移量 off 开始，写入 len 个字节
void write(int b)：将指定的字节写入该文件
writeUTF(String str)：将一个字符串以 UTF-8 编码写入文件

2.3 Apache FileUtils 类

FileUtils 类是 Apache Commons IO 库中的一个类，提供了一些更为方便的方法来操作文件或目录

1）复制文件或者目录

File srcFile = new File("path/src/file");
File destFile = new File("path/dest/file");
// 复制文件
FileUtils.copyFile(srcFile, destFile);
// 复制目录
FileUtils.copyDirectory(srcFile, destFile);

2）删除文件或者目录

File file = new File("path/file");
// 删除文件或目录
FileUtils.delete(file);

注：如果要删除一个非空目录，需要先删除目录中的所有文件和子目录

3）移动文件或者目录

File srcFile = new File("path/to/src/file");
File destFile = new File("path/to/dest/file");
// 移动文件或目录
FileUtils.moveFile(srcFile, destFile);

4）查询文件或者目录信息

File file = new File("path/file");
// 获取文件或目录的修改时间
Date modifyTime = FileUtils.lastModified(file);
// 获取文件或目录的大小
long size = FileUtils.sizeOf(file);
// 获取文件或目录的扩展名
String extension = FileUtils.getExtension(file.getName());

2.4 Hutool FileUtil 类

1）复制文件

将指定的源文件复制到指定的目标文件中

File dest = FileUtil.file("FileUtilDemo2.java");
FileUtil.copyFile(file, dest);

2）移动文件或目录

FileUtil.move(file, dest, true);

3）删除文件或目录

FileUtil.del(file);

4）重命名

FileUtil.rename(file, "FileUtilDemo3.java", true);

5）读取每一行数据

FileUtil.readLines(file, "UTF-8").forEach(System.out::println);

3. 字节流

一切文件（文本、视频、图片）的数据都是以二进制的形式存储的，传输时也是。所以，字节流可以传输任意类型的文件数据

3.1 字节输出流

OutputStream 是字节输出流的超类（父类），它定义的一些共性方法：

close()：关闭此输出流并释放与此流相关联的系统资源
flush()：刷新此输出流并强制缓冲区的字节被写入到目的地
write(byte[] b)：将 b.length 个字节从指定的字节数组写入此输出流
write(byte[ ] b, int off, int len)：从指定的字节数组写入 len 字节到此输出流，从偏移量 off开始。?也就是说从off个字节数开始一直到len个字节结束

FileOutputStream类，用于将数据写入到文件

1）FileOutputStream 构造方法

1. 使用文件名创建：

String fileName = "example.txt";
FileOutputStream fos = new FileOutputStream(fileName);

使用文件名 "example.txt" 创建一个 FileOutputStream 对象，将数据写入到该文件中。如果文件不存在，则创建一个新文件；如果文件已经存在，则覆盖原有文件

2. 使用文件对象创建

File file = new File("example.txt");
FileOutputStream fos = new FileOutputStream(file);

使用示例：

FileOutputStream fos = null;
try {
  fos = new FileOutputStream("example.txt");
  fos.write("你好呀".getBytes());
} catch (IOException e) {
  e.printStackTrace();
} finally {
  if (fos != null) {
    try {
      fos.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

创建一个 FileOutputStream 对象，将字符串 "你好呀" 写入到 example.txt 文件中，最后关闭了输出流

2）FileOutputStream 写入字节数据

1. 写入字节

// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");     
// 写出数据
fos.write(97); // 第1个字节 等价于 fos.write('a');
fos.write(98); // 第2个字节 等价于 fos.write('b');
fos.write(99); // 第3个字节 等价于 fos.write('c');
// 关闭资源
fos.close();

注：一个字节只有8位，因此参数 b 的取值范围应该在 0 到 255 之间，超出这个范围的值将会被截断；当将一个整型值传递给 write(int b) 方法时，方法会将该值转换为 byte 类型，发生截断只会将参数 b 的低8位写入，而忽略高24位

2. 写入字节数组

// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");     
// 字符串转换为字节数组
byte[] b = "在深度学习里迷路".getBytes();
// 写入字节数组数据
fos.write(b);
// 关闭资源
fos.close();

3. 写入指定长度字节数组

// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");     
// 字符串转换为字节数组
byte[] b = "abcde".getBytes();
// 从索引2开始，2个字节。索引2是c，
fos.write(b,2,2);  //写进去的就是 cd
// 关闭资源
fos.close();

3）实现数据追加、换行

1.?使用文件名和追加标志创建 FileOutputStream 对象

String fileName = "example.txt";
boolean append = true;
FileOutputStream fos = new FileOutputStream(fileName, append);

如果文件不存在，则创建一个新文件；如果文件已经存在，则在文件末尾追加数据。

true?表示追加数据，false?表示不追加也就是清空原有数据

2.?使用文件对象和追加标志创建 FileOutputStream 对象

File file = new File("example.txt");
boolean append = true;
FileOutputStream fos = new FileOutputStream(file, append);

如果文件不存在，则创建一个新文件；如果文件已经存在，则在文件末尾追加数据

3.?Windows 中，换行符号 \r\n

String filename = "example.txt";
FileOutputStream fos = new FileOutputStream(filename, true);  // 追加模式
String content = "你好呀\r\n";  // 使用回车符和换行符的组合
fos.write(content.getBytes());
fos.close();

4. macOS 中，换行符 \n

String filename = "example.txt";
FileOutputStream fos = new FileOutputStream(filename, true);  // 追加模式
String content = "macOS使用的换行符\n";  // 只使用换行符
fos.write(content.getBytes());
fos.close();

3.2 字节输入流

InputStream?是字节输入流的超类（父类），它的一些共性方法：

close()：关闭此输入流并释放与此流相关的系统资源
int read()：从输入流读取数据的下一个字节
read(byte[ ] b)：该方法返回的 int 值代表的是读取了多少个字节，读到几个返回几个，读取不到返回-1

FileInputStream 就是一个子类，是文件输入流，用于将数据从文件中读取数据

1）构造方法

1. FileInputStream(String name)

创建一个 FileInputStream 对象，并打开指定名称的文件进行读取。如果文件不存在，将会抛出 FileNotFoundException 异常

2. FileInputStream(File file)

创建一个 FileInputStream 对象，并打开指定的 File 对象表示的文件进行读取

2）读取字节数据

1. 读取字节

// 创建一个 FileInputStream 对象
FileInputStream fis = new FileInputStream("test.txt");

// 读取文件内容
int data;
while ((data = fis.read()) != -1) {
    System.out.print((char) data);
}

// 关闭输入流
fis.close();

读取一个字节并返回其整数表示。如果已经到达文件的末尾，则返回 -1。如果在读取时发生错误，则会抛出 IOException 异常

2. 字节数组读取

从输入流中最多读取 b.length 个字节，并将它们存储到缓冲区数组 b 中

// 创建一个 FileInputStream 对象
FileInputStream fis = new FileInputStream("test.txt");

// 读取文件内容到缓冲区
byte[] buffer = new byte[1024];
int count;
while ((count = fis.read(buffer)) != -1) {
    System.out.println(new String(buffer, 0, count));
}

// 关闭输入流
fis.close();

3）复制文件

原理：将文件读入到字节输入流，然后通过字节输出流写入文件

// 创建一个 FileInputStream 对象以读取原始图片文件
FileInputStream fis = new FileInputStream("original.jpg");

// 创建一个 FileOutputStream 对象以写入复制后的图片文件
FileOutputStream fos = new FileOutputStream("copy.jpg");

// 创建一个缓冲区数组以存储读取的数据
byte[] buffer = new byte[1024];
int count;

// 读取原始图片文件并将数据写入复制后的图片文件
while ((count = fis.read(buffer)) != -1) {
    fos.write(buffer, 0, count);
}

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

4. 字符流

字符流是一种用于读取和写入字符数据的输入输出流。与字节流不同，字符流以字符为单位读取和写入数据，常用来处理文本信息

注：?字符流 = 字节流 + 编码表（要注意处理乱码问题）

4.1 字符输入流

java.io.Reader?是字符输入流的超类（父类），定义了字符输入流的一些共性方法：

close()：关闭此流并释放与此流相关的系统资源
read()：从输入流读取一个字符
read(char[ ] cbuf)：从输入流中读取一些字符，并将它们存储到字符数组 cbuf 中

FileReader 是 Reader 的子类，用于从文件中读取字符数据

1）构造方法

FileReader(File file)：创建一个新的 FileReader，参数为File对象
FileReader(String fileName)：创建一个新的 FileReader，参数为文件名

// 使用File对象创建流对象
File file = new File("a.txt");
FileReader fr = new FileReader(file);

// 使用文件名称创建流对象
FileReader fr = new FileReader("b.txt");

2）读取数据

1. 读取字符

每次可以读取一个字符，返回读取的字符（转为 int 类型），当读取到文件末尾时，返回?-1

// 使用文件名称创建流对象
FileReader fr = new FileReader("abc.txt");
// 定义变量，保存数据
int b;
// 循环读取
while ((b = fr.read())!=-1) {
    System.out.println((char)b);
}
// 关闭资源
fr.close();

2. 读取指定长度的字符

每次读取 len 个字符，然后使用 String 构造方法将其转换为字符串并输出

File textFile = new File("docs.md");
// 给一个 FileReader 的示例
// try-with-resources FileReader
try(FileReader reader = new FileReader(textFile);) {
    // read(char[] cbuf)
    char[] buffer = new char[1024];
    int len;
    while ((len = reader.read(buffer, 0, buffer.length)) != -1) {
        System.out.print(new String(buffer, 0, len));
    }
}

4.2 字符输出流

java.io.Writer?是字符输出流类的超类（父类），它定义的一些共性方法：

write(int c)：写入单个字符
write(char[ ] cbuf)：写入字符数组
write(char[ ] cbuf, int off, int len)：写入字符数组的一部分，off为开始索引，len为字符个数
write(String str)：写入字符串
write(String str, int off, int len)：写入字符串的某一部分
flush()：刷新该流的缓冲
close()：关闭此流，但要先刷新它

FileWrite 是 Writer 子类，用来将字符写入到文件

1）构造方法

// 第一种：使用File对象创建流对象
File file = new File("a.txt");
FileWriter fw = new FileWriter(file);

// 第二种：使用文件名称创建流对象
FileWriter fw = new FileWriter("b.txt");

2）写入数据

1. 写入字符，每次可以写出一个字符

FileWriter fw = null;
try {
    fw = new FileWriter("output.txt");
    fw.write(72); // 写入字符'H'的ASCII码
    fw.write(101); // 写入字符'e'的ASCII码
    fw.write(108); // 写入字符'l'的ASCII码
    fw.write(108); // 写入字符'l'的ASCII码
    fw.write(111); // 写入字符'o'的ASCII码
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        if (fw != null) {
            fw.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

注：

1. writer(int b) 写入的是一个字节，而不是一个字符

2. writer(char cbuf[ ])? writer(String str)?写入字符

?2. 写入字符数组

FileWriter fw = null;
try {
    fw = new FileWriter("output.txt");
    char[] chars = {'H', 'e', 'l', 'l', 'o'};
    fw.write(chars); // 将字符数组写入文件
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        if (fw != null) {
            fw.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

3. 写入指定字符数组

fw = new FileWriter("output.txt");
    char[] chars = {'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!'};
fw.write(chars, 0, 5); // 将字符数组的前 5 个字符写入文件

4. 写入字符串

fw = new FileWriter("output.txt");
String str = "你好呀，哈哈哈";
fw.write(str); // 将字符串写入文件

5. 写入指定字符串

String str = "这个时间变得好快呀！";
try (FileWriter fw = new FileWriter("output.txt")) {
    fw.write(str, 0, 5); // 将字符串的前 5 个字符写入文件
} catch (IOException e) {
    e.printStackTrace();
}

3）关闭、刷新

因为 FileWriter 内置了缓冲区 ByteBuffer，所以如果不关闭输出流，就无法把字符写入到文件中

关闭了流对象，就无法继续写数据了。如果既想写入数据，又想继续使用流，就需要 flush()、

注：即便是flush方法写出了数据，操作的最后还是要调用close方法，释放系统资源。当然你也可以用 try-with-resources 的方式

?4）续写与换行

// 使用文件名称创建流对象，可以续写数据
FileWriter fw = new FileWriter("fw.txt",true);     
// 写出字符串
fw.write("你好");
// 写出换行
fw.write("\r\n");
// 写出字符串
fw.write("世界");
// 关闭资源
fw.close();

5）文本文件的复制

public class CopyFile {
    public static void main(String[] args) throws IOException {
        //创建输入流对象
        FileReader fr=new FileReader("aa.txt");//文件不存在会抛出java.io.FileNotFoundException
        //创建输出流对象
        FileWriter fw=new FileWriter("copyaa.txt");
        /*创建输出流做的工作：
         * 1、调用系统资源创建了一个文件
         * 2、创建输出流对象
         * 3、把输出流对象指向文件        
         * */
        //文本文件复制，一次读一个字符
        copyMethod1(fr, fw);
        //文本文件复制，一次读一个字符数组
        copyMethod2(fr, fw);
        
        fr.close();
        fw.close();
    }

    public static void copyMethod1(FileReader fr, FileWriter fw) throws IOException {
        int ch;
        while((ch=fr.read())!=-1) {//读数据
            fw.write(ch);//写数据
        }
        fw.flush();
    }

    public static void copyMethod2(FileReader fr, FileWriter fw) throws IOException {
        char chs[]=new char[1024];
        int len=0;
        while((len=fr.read(chs))!=-1) {//读数据
            fw.write(chs,0,len);//写数据
        }
        fw.flush();
    }
}

5. 缓冲流

工作原理：将数据先写入缓冲区中，当缓冲区满时再一次性写入文件或输出流，或者当缓冲区为空时一次性从文件或输入流中读取一定量的数据。

目的：减少系统的 I/O 操作次数，提高系统的 I/O 效率，从而提高程序的运行效率

5.1 字节缓冲流

BufferedInputStream 和 BufferedOutputStream 属于字节缓冲流

1）构造方法

// 创建字节缓冲输入流，先声明字节流
FileInputStream fps = new FileInputStream(b.txt);
BufferedInputStream bis = new BufferedInputStream(fps)

// 创建字节缓冲输入流（一步到位）
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("b.txt"));

// 创建字节缓冲输出流（一步到位）
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.txt"));

2）缓冲流解决的问题

思想：一次多读点多写点，减少读写的频率，用空间换时间

BufferedInputStream 的 read 方法：

public synchronized int read() throws IOException {
    if (pos >= count) {     // 如果当前位置已经到达缓冲区末尾
        fill();             // 填充缓冲区
        if (pos >= count)   // 如果填充后仍然到达缓冲区末尾，说明已经读取完毕
            return -1;      // 返回 -1 表示已经读取完毕
    }
    return getBufIfOpen()[pos++] & 0xff; // 返回当前位置的字节，并将位置加 1
}

FileInputStream 的 read 方法：

调用的是系统底层的方法 read0() ，不同系统上它们的功能都是相同的，都是用于读取一个字节

BufferedOutputStream 的 write 方法:

public synchronized void write(byte b[], int off, int len) throws IOException {
    if (len >= buf.length) {    // 如果写入的字节数大于等于缓冲区长度
        /* 如果请求的长度超过了输出缓冲区的大小，
           先刷新缓冲区，然后直接将数据写入。
           这样可以避免缓冲流级联时的问题。*/
        flushBuffer();          // 先刷新缓冲区
        out.write(b, off, len); // 直接将数据写入输出流
        return;
    }
    if (len > buf.length - count) { // 如果写入的字节数大于空余空间
        flushBuffer();              // 先刷新缓冲区
    }
    System.arraycopy(b, off, buf, count, len); // 将数据拷贝到缓冲区中
    count += len;                             // 更新计数器
}

思想：

检查写入的字节数是否大于等于缓冲区长度
如果是，则先将缓冲区中的数据刷新到磁盘中，然后直接将数据写入输出流
如果写入的字节数小于缓冲区长度，则检查缓冲区中剩余的空间是否足够容纳要写入的字节数，如果不够，则先将缓冲区中的数据刷新到磁盘中
使用?System.arraycopy()?方法将要写入的数据拷贝到缓冲区中，并更新计数器 count
如果写入的字节数小于缓冲区长度且缓冲区中还有剩余空间，则直接将要写入的数据拷贝到缓冲区中，并更新计数器 count

步骤 1?的目的：避免缓冲流级联时的问题 ->?缓冲区的大小不足以容纳写入的数据时，可能会引发级联刷新，导致效率降低

级联问题（Cascade Problem）是指在一组缓冲流（Buffered Stream）中，由于缓冲区的大小不足以容纳要写入的数据，导致数据被分割成多个部分，并分别写入到不同的缓冲区中，最终需要逐个刷新缓冲区，从而导致性能下降的问题。

?也就是说，只有当 buf 写满了，才会 flush，将数据刷到磁盘，默认一次刷 8192 个字节

public BufferedOutputStream(OutputStream out) {
    this(out, 8192);
}

如果 buf 没有写满，会继续写 buf

3）byte & 0xFF

byte 类型是有符号的，即其取值范围为 -128 到 127。如果我们希望得到的是一个无符号的 byte 值，就需要使用?byte & 0xFF?来进行转换

?5.2 字符缓冲流

BufferedReader 类继承自 Reader 类，readLine()?方法可以一次读取一行数据，而不是一个字符一个字符地读取

BufferedWriter 类继承自 Writer 类，newLine() 方法可以写入一个系统特定的行分隔符

1）构造方法

// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("b.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

2）特有方法

BufferedReader 类：readLine()?方法可以一次读取一行数据
BufferedWriter 类：newLine() 方法可以换行

// 创建流对象
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
// 定义字符串,保存读取的一行文字
String line  = null;
// 循环读取,读取到最后返回null
while ((line = br.readLine())!=null) {
    System.out.print(line);
    System.out.println("------");
}
// 释放资源
br.close();

// 创建流对象
BfferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
// 写出数据
bw.write("你");
// 写出换行
bw.newLine();
bw.write("好");
bw.newLine();
bw.write("呀");
bw.newLine();
// 释放资源
bw.close();

6. 转换流

转换流主要有两种类型：InputStreamReader 和 OutputStreamWriter

6.1 编码与解码

在计算机中，数据通常以二进制形式存储和传输

编码就是将原始数据（比如说文本、图像、视频、音频等）转换为二进制形式
解码就是将二进制数据转换为原始数据，是一个反向的过程

String str = "你好";
String charsetName = "UTF-8";

// 编码
byte[] bytes = str.getBytes(Charset.forName(charsetName));
System.out.println("编码: " + bytes);

// 解码
String decodedStr = new String(bytes, Charset.forName(charsetName));
System.out.println("解码: " + decodedStr);

6.2 字符集

Charset：字符集，是一组字符的集合，每个字符都有一个唯一的编码值，也称为码点

?6.3 InputStreamReader

作用是将字节流（InputStream）转换为字符流（Reader），同时支持指定的字符集编码方式，从而实现字符流与字节流之间的转换

1）构造方法

// 创建一个使用默认字符集的字符流
InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
// 创建一个指定字符集的字符流
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

2）解决编码

String s = "你好呀！";

try {
    // 将字符串按GBK编码方式保存到文件中
    OutputStreamWriter outUtf8 = new OutputStreamWriter(
            new FileOutputStream("logs/test_utf8.txt"), "GBK");
    outUtf8.write(s);
    outUtf8.close();

    // 将字节流转换为字符流，使用GBK编码方式
    InputStreamReader isr = new InputStreamReader(new         
        FileInputStream("logs/test_utf8.txt"), "GBK");
    // 读取字符流
    int c;
    while ((c = isr.read()) != -1) {
        System.out.print((char) c);
    }
    isr.close();
} catch (IOException e) {
    e.printStackTrace();
}

6.4?OutputStreamWriter

将字符流转换为字节流，是字符流到字节流的桥梁

1）构造方法

// 创建一个使用默认字符集的字符流
OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("a.txt"));
// 创建一个指定字符集的字符流
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("b.txt") , "GBK");

2）使用

通常为了提高读写效率，我们会在转换流上再加一层 缓冲流

try {
    // 从文件读取字节流，使用UTF-8编码方式
    FileInputStream fis = new FileInputStream("test.txt");
    // 将字节流转换为字符流，使用UTF-8编码方式
    InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
    // 使用缓冲流包装字符流，提高读取效率
    BufferedReader br = new BufferedReader(isr);
    // 创建输出流，使用UTF-8编码方式
    FileOutputStream fos = new FileOutputStream("output.txt");
    // 将输出流包装为转换流，使用UTF-8编码方式
    OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
    // 使用缓冲流包装转换流，提高写入效率
    BufferedWriter bw = new BufferedWriter(osw);

    // 读取输入文件的每一行，写入到输出文件中
    String line;
    while ((line = br.readLine()) != null) {
        bw.write(line);
        bw.newLine(); // 每行结束后写入一个换行符
    }

    // 关闭流
    br.close();
    bw.close();
} catch (IOException e) {
    e.printStackTrace();
}

7. 序列流

一种可以将 Java 对象序列化和反序列化的流

在 Java 中，序列化通过实现 java.io.Serializable 接口来实现，只有实现了 Serializable 接口的对象才能被序列化

反序列化是指将一个字节序列转换为一个对象，以便在程序中使用

7.1?ObjectOutputStream

java.io.ObjectOutputStream 继承自OutputStream 类，因此可以将序列化后的字节序列写入到文件、网络等输出流中

1）构造方法

构造方法接收一个 OutputStream 对象作为参数，将序列化后的字节序列输出到指定的输出流中

FileOutputStream fos = new FileOutputStream("file.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);

一个对象要想序列化，必须满足两个条件:

实现 java.io.Serializable 接口
该类的所有字段都必须是可序列化的。如果一个字段不需要序列化，则需要使用 transient 关键字进行修饰

public class Employee implements Serializable {
    public String name;
    public String address;
    public transient int age; // transient瞬态修饰成员,不会被序列化
}

2）使用

writeObject 方法，将对象序列化成字节序列并输出到输出流中的方法，可以处理对象之间的引用关系、继承关系、静态字段和 transient 字段

public class ObjectOutputStreamDemo {
    public static void main(String[] args) {
        Person person = new Person("小林", 20);
        try {
            FileOutputStream fos = new FileOutputStream("logs/person.dat");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(person);
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
class Person implements Serializable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

7.2?ObjectInputStream

ObjectInputStream 可以读取 ObjectOutputStream 写入的字节流，并将其反序列化为相应的对象

1）构造及使用

String filename = "logs/person.dat"; // 待反序列化的文件名
try (FileInputStream fileIn = new FileInputStream(filename);
     ObjectInputStream in = new ObjectInputStream(fileIn)) {
     // 从指定的文件输入流中读取对象并反序列化
     Object obj = in.readObject();
     // 将反序列化后的对象强制转换为指定类型
     Person p = (Person) obj;
     // 打印反序列化后的对象信息
     System.out.println("Deserialized Object: " + p);
} catch (IOException | ClassNotFoundException e) {
     e.printStackTrace();
}

7.3 Kryo

实际开发中，很少使用 JDK 自带的序列化和反序列化

可移植性差：Java 特有的，无法跨语言进行序列化和反序列化
性能差：序列化后的字节体积大，增加了传输/保存成本
安全问题：应用安全:JAVA反序列化漏洞之殇

Kryo 是一个优秀的 Java 序列化和反序列化库，具有高性能、高效率和易于使用和扩展等特点

地址：https://github.com/EsotericSoftware/kryo

?使用：

1.?在 pom.xml 中引入依赖

<!-- 引入 Kryo 序列化工具 -->
<dependency>
     <groupId>com.esotericsoftware</groupId>
     <artifactId>kryo</artifactId>
     <version>5.4.0</version>
</dependency>

2. 调用

public class KryoDemo {
    public static void main(String[] args) throws FileNotFoundException {
        Kryo kryo = new Kryo();
        // 将对象进行注册
        kryo.register(KryoParam.class);

        KryoParam object = new KryoParam("小林", 123);

        Output output = new Output(new FileOutputStream("logs/kryo.bin"));
        kryo.writeObject(output, object);
        output.close();

        Input input = new Input(new FileInputStream("logs/kryo.bin"));
        KryoParam object2 = kryo.readObject(input, KryoParam.class);
        System.out.println(object2);
        input.close();
    }
}

class KryoParam {
    private String name;
    private int age;

    public KryoParam() {
    }

    public KryoParam(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "KryoParam{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

8. 打印流

PrintStream 是 OutputStream 的子类（字节流），PrintWriter 是 Writer 的子类（字符流）

特点：

可以自动进行数据类型转换：打印流可以将各种数据类型转换为字符串，并输出到指定的输出流中。
可以自动进行换行操作：打印流可以在输出字符串的末尾自动添加换行符，方便输出多个字符串时的格式控制。
可以输出到控制台或者文件中：打印流可以将数据输出到控制台或者文件中，方便调试和日志记录

?printf 方法

常用转换说明符及对应的输出格式：

%s：输出一个字符串。
%d?或?%i：输出一个十进制整数。
%x?或?%X：输出一个十六进制整数，%x?输出小写字母，%X?输出大写字母。
%f?或?%F：输出一个浮点数。
%e?或?%E：输出一个科学计数法表示的浮点数，%e?输出小写字母 e，%E?输出大写字母 E。
%g?或?%G：输出一个浮点数，自动选择?%f?或?%e/%E?格式输出。
%c：输出一个字符。
%b：输出一个布尔值。
%h：输出一个哈希码（16进制）。
%n：换行符。

还支持一些修饰符，用于指定输出的宽度、精度、对齐方式等

宽度修饰符：用数字指定输出的最小宽度，如果输出的数据不足指定宽度，则在左侧或右侧填充空格或零。
精度修饰符：用点号（.）和数字指定浮点数或字符串的精度，对于浮点数，指定小数点后的位数，对于字符串，指定输出的字符数。
对齐修饰符：用减号（-）或零号（0）指定输出的对齐方式，减号表示左对齐，零号表示右对齐并填充零。

int num = 123;
System.out.printf("%5d\n", num); // 输出 "  123"
System.out.printf("%-5d\n", num); // 输出 "123  "
System.out.printf("%05d\n", num); // 输出 "00123"

double pi = Math.PI;
System.out.printf("%10.2f\n", pi); // 输出 "      3.14"
System.out.printf("%-10.4f\n", pi); // 输出 "3.1416    "

String name = "是打印流";
System.out.printf("%10s\n", name); // 输出 "     是打印流"
System.out.printf("%-10s\n", name); // 输出 "是打印流     "

文章来源:https://blog.csdn.net/lin_xiangxiang/article/details/135377947
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！