Java基础知识——IO流

Love The Way You Lie 2023-07-10 05:12 28阅读 0赞

### 简介 ###

IO是指Input/Output，即输入和输出。以内存为中心：

*  Input指从外部读入数据到内存，例如，把文件从磁盘读取到内存，从网络读取数据到内存等等
 *  Output指把数据从内存输出到外部，例如，把数据从内存写入到文件，把数据从内存输出到网络等等

为什么要把数据读到内存才能处理这些数据？因为代码是在内存中运行的，数据也必须读到内存，最终的表示方式无非是byte数组，字符串等，都必须存放在内存里。Java标准库的java.io包提供了同步IO功能：其中字节流接口为：InputStream/OutputStream；字符流接口为：Reader/Writer

### 流家族层次图 ###

我们把输入、输出流家族中的成员按照它们的使用方法来进行划分，这样就形成了处理**字节**和**字符**的两个单独的层次结构。其中Java拥有一个流家族，包含各种输入、输出流类型，其数量超过60个之多，详情如下所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70]  
另一方面，处理文本数据，使用的是抽象类Reader和Writer的子类，字符流是因为数据编码的不同，而有了对字符进行高效操作的流对象。**本质其实就是基于字节流读取时，去查了指定的码表，一次可能读取多个字节**。 其结构层次图如下：  
注：只要是处理纯文本数据，就优先考虑使用字符流，这样做更加**方便**且**高效**，除此之外其它类型都使用字节流  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70 1]  
除此之外还有四个重要的接口：**Closeable**、**Flushable**、**Readable**、和**Appendable**。其中java.io.Closeable接口扩展了java.lang.AutoCloseable接口，因此对任何Closeable进行操作时，都可以使用**try-with-resource**语句，且Closeable接口的close方法只能抛出IOException，而AutoCloseable.close方法可以抛出任何异常  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70 2]

### IO流分类 ###

IO流涉及的类实在太多，不太方便记忆与学习，这里按不同方向分一下类，这样只记典型，触类旁通

##### 按操作方式 #####

*  **字节流**：以字节为单位，每次次读入或读出是8位数据。可以读任何类型数据
 *  **字符流**：以字符为单位，每次次读入或读出是16位数据。其只能读取字符类型数据

##### 输出流和输入流 #####

*  **输出流**：从内存读出到文件。只能进行写操作
 *  **输入流**：从文件、网络等读入到内存。只能进行读操作

##### 节点流和处理流 #####

*  **节点流**：直接与数据源相连，读入或读出
 *  **处理流**：与节点流一块使用，在节点流的基础上，再套接一层，套接在节点流上的就是处理流

##### 按操作方式分类结构图 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70 3]

##### 按操作对象分类结构图 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70 4]

### File对象 ###

在计算机系统中，文件是非常重要的存储方式。Java的标准库java.io提供了File对象来操作文件和目录。构造File对象时，既可以传入绝对路径，也可以传入相对路径。绝对路径是以根目录开头的完整路径，例如：

File f = new File("C:\\Windows\\notepad.exe");

注意Windows平台使用\\作为路径分隔符，在Java字符串中需要用\\表示一个\\。Linux平台使用/作为路径分隔符：

File f = new File("/usr/bin/javac");

传入相对路径时，相对路径前面加上当前目录就是绝对路径：

// 假设当前目录是C:\Docs
    File f1 = new File("sub\\javac"); // 绝对路径是C:\Docs\sub\javac
    File f3 = new File(".\\sub\\javac"); // 绝对路径是C:\Docs\sub\javac
    File f3 = new File("..\\sub\\javac"); // 绝对路径是C:\sub\javac

File对象有3种形式表示的路径，一种是getPath()，返回构造方法传入的路径，一种是getAbsolutePath()，返回绝对路径，一种是getCanonicalPath，它和绝对路径类似，但是返回的是规范路径。

##### 文件和目录 #####

File对象既可以表示文件，也可以表示目录。特别要注意的是，构造一个File对象，即使传入的文件或目录不存在，代码也不会出错，因为构造一个File对象，并不会导致任何磁盘操作。只有当我们调用File对象的某些方法的时候，才真正进行磁盘操作。获取到一个文件时，还可以进一步判断文件的权限和大小：

*  boolean canRead()：是否可读；
 *  boolean canWrite()：是否可写；
 *  boolean canExecute()：是否可执行；
 *  long length()：文件字节大小。

###### 创建和删除文件 ######

当File对象表示一个文件时，可以通过createNewFile()创建一个新文件，用delete()删除该文件：

File file = new File("/path/to/file");
    if (file.createNewFile()) {
        // 文件创建成功:
        // TODO:
        if (file.delete()) {
            // 删除文件成功:
        }
    }

有些时候，程序需要读写一些临时文件，File对象提供了createTempFile()来创建一个临时文件，以及deleteOnExit()在JVM退出时自动删除该文件。

public class Main {
        public static void main(String[] args) throws IOException {
            File f = File.createTempFile("tmp-", ".txt"); // 提供临时文件的前缀和后缀
            f.deleteOnExit(); // JVM退出时自动删除
            System.out.println(f.isFile());
            System.out.println(f.getAbsolutePath());
        }
    }

##### 遍历文件和目录 #####

当File对象表示一个目录时，可以使用list()和listFiles()列出目录下的文件和子目录名。listFiles()提供了一系列重载方法，可以过滤不想要的文件和目录，和文件操作类似，File对象如果表示一个目录，可以通过以下方法创建和删除目录：

*  boolean mkdir()：创建当前File对象表示的目录；
 *  boolean mkdirs()：创建当前File对象表示的目录，并在必要时将不存在的父目录也创建出来；
 *  boolean delete()：删除当前File对象表示的目录，当前目录必须为空才能删除成功。

##### Path #####

Java标准库还提供了一个Path对象，它位于java.nio.file包。Path对象和File对象类似，但操作更加简单：

Path p1 = Paths.get(".", "project", "study"); // 构造一个Path对象
            System.out.println(p1);
            Path p2 = p1.toAbsolutePath(); // 转换为绝对路径
            System.out.println(p2);
            Path p3 = p2.normalize(); // 转换为规范路径
            System.out.println(p3);
            File f = p3.toFile(); // 转换为File对象
            System.out.println(f);
            for (Path p : Paths.get("..").toAbsolutePath()) { // 可以直接遍历Path
                System.out.println("  " + p);
            }

如果需要对目录进行复杂的拼接、遍历等操作，使用Path对象更方便。

### InputStream ###

InputStream就是Java标准库提供的最基本的输入流。它位于java.io这个包里。java.io包提供了所有同步IO的功能。要特别注意的一点是，InputStream并不是一个接口，而是一个抽象类，它是所有输入流的超类。这个抽象类定义的一个最重要的方法就是int read()，这个方法会读取输入流的下一个字节，并返回字节表示的int值（0~255）。如果已读到末尾，返回-1表示不能继续读取了，签名如下：

public abstract int read() throws IOException;

应用程序在运行的过程中，如果打开了一个文件进行读写，完成后要及时地关闭，以便让操作系统把资源释放掉，否则，应用程序占用的资源会越来越多，不但白白占用内存，还会影响其他应用程序的运行。InputStream和OutputStream都是通过close()方法来关闭流。关闭流就会释放对应的底层资源。可用try … finally来保证InputStream在无论是否发生IO错误的时候都能够正确地关闭，除了try … finally还可以用，Java 7引入的新的try(resource)的语法，只需要编写try语句，让编译器自动为我们关闭资源。推荐的写法如下：

public void readFile() throws IOException {
        try (InputStream input = new FileInputStream("src/readme.txt")) {
            int n;
            while ((n = input.read()) != -1) {
                System.out.println(n);
            }
        } // 编译器在此自动为我们写入finally并调用close()
    }

实际上，编译器并不会特别地为InputStream加上自动关闭。编译器只看try(resource = …)中的对象是否实现了java.lang.AutoCloseable接口，如果实现了，就自动加上finally语句并调用close()方法。InputStream和OutputStream都实现了这个接口，因此，都可以用在try(resource)中。

##### 缓冲 #####

在读取流的时候，一次读取一个字节并不是最高效的方法。很多流支持一次性读取多个字节到缓冲区，对于文件和网络流来说，利用缓冲区一次性读取多个字节效率往往要高很多。InputStream提供了两个重载方法来支持读取多个字节：

*  int read(byte\[\] b)：读取若干字节并填充到byte\[\]数组，返回读取的字节数
 *  int read(byte\[\] b, int off, int len)：指定byte\[\]数组的偏移量和最大填充数

利用上述方法一次读取多个字节时，需要先定义一个byte\[\]数组作为缓冲区，read()方法会尽可能多地读取字节到缓冲区， 但不会超过缓冲区的大小。read()方法的返回值不再是字节的int值，而是返回实际读取了多少个字节。如果返回-1，表示没有更多的数据了。

##### 阻塞 #####

在调用InputStream的read()方法读取数据时，我们说read()方法是阻塞（Blocking）的。它的意思是，对于下面的代码：

int n;
    n = input.read(); // 必须等待read()方法返回才能执行下一行代码
    int m = n;

执行到第二行代码时，必须等read()方法返回后才能继续。因为读取IO流相比执行普通代码，速度会慢很多，因此，无法确定read()方法调用到底要花费多长时间

### OutputStream ###

和InputStream类似，OutputStream也是抽象类，它是所有输出流的超类。这个抽象类定义的一个最重要的方法就是void write(int b)，签名如下：

public abstract void write(int b) throws IOException;

这个方法会写入一个字节到输出流。要注意的是，虽然传入的是int参数，但只会写入一个字节，即只写入int最低8位表示字节的部分（相当于b & 0xff）和InputStream类似，OutputStream也提供了close()方法关闭输出流，以便释放系统资源。要特别注意：OutputStream还提供了一个flush()方法，它的目的是将缓冲区的内容真正输出到目的地。通常情况下，我们不需要调用这个flush()方法，因为缓冲区写满了OutputStream会自动调用它，并且，在调用close()方法关闭OutputStream之前，也会自动调用flush()方法，但某些情况下我们要手动调用，即需要不管当前缓冲区是否已满，都要输出内容时

##### 阻塞 #####

和InputStream一样，OutputStream的write()方法也是阻塞的

### Filter模式 ###

Java的IO标准库提供的InputStream根据来源可以包括

*  FileInputStream：从文件读取数据，是最终数据源；
 *  ServletInputStream：从HTTP请求读取数据，是最终数据源；
 *  Socket.getInputStream()：从TCP连接读取数据，是最终数据源；
 *  …

如果我们要添加一些如**缓冲**、**签名**、**加密**、**解密**功能，我们应该怎么做，再派生一个子类吗？这样做可以实现，但是有一个问题是，数据来源多种多样，疯狂派生子类会导致子类爆炸，所以这里用到了一种设计模式，叫**装饰器模式(Decorator)**,首先我们将InputStream分为两大类：  
一类是直接提供数据的基础InputStream，例如：

*  FileInputStream
 *  ByteArrayInputStream
 *  ServletInputStream
 *  …

一类是提供额外附加功能的InputStream，例如：

*  BufferedInputStream
 *  DigestInputStream
 *  CipherInputStream
 *  …

当我们需要给一个"基础"InputStream附加各种功能时，我们先确定这个能提供数据源的InputStream，因为我们需要的数据总得来自某个地方，例如，FileInputStream，数据来源自文件：

InputStream file = new FileInputStream("test.gz");

紧接着，我们希望FileInputStream能提供缓冲的功能来提高读取的效率，因此我们用BufferedInputStream包装这个InputStream，得到的包装类型是BufferedInputStream，但它仍然被视为一个InputStream：

InputStream buffered = new BufferedInputStream(file)

最后，假设该文件已经用gzip压缩了，我们希望直接读取解压缩的内容，就可以再包装一个GZIPInputStream：

InputStream gzip = new GZIPInputStream(buffered);

无论我们包装多少次，得到的对象始终是InputStream，我们直接用InputStream来引用它，就可以正常读取：  
![在这里插入图片描述][20200811103211628.png]  
注意到在叠加多个FilterInputStream，我们只需要持有最外层的InputStream，并且，当最外层的InputStream关闭时（在try(resource)块的结束处自动关闭），内层的InputStream的close()方法也会被自动调用，并最终调用到最核心的"基础"InputStream，因此不存在资源泄露

### 操作Zip ###

ZipInputStream是一种FilterInputStream，它可以直接读取zip包的内容：  
![在这里插入图片描述][20200229171434391.png]  
另一个JarInputStream是从ZipInputStream派生，它增加的主要功能是直接读取jar文件里面的MANIFEST.MF文件。因为本质上jar包就是zip包，只是额外附加了一些固定的描述文件。

##### 读取zip包 #####

我们要创建一个ZipInputStream，通常是传入一个FileInputStream作为数据源，然后，循环调用getNextEntry()，直到返回null，表示zip流结束。一个ZipEntry表示一个压缩文件或目录，如果是压缩文件，我们就用read()方法不断读取，直到返回-1：

try (ZipInputStream zip = new ZipInputStream(new FileInputStream(...))) {
        ZipEntry entry = null;
        while ((entry = zip.getNextEntry()) != null) {
            String name = entry.getName();
            if (!entry.isDirectory()) {
                int n;
                while ((n = zip.read()) != -1) {
                    ...
                }
            }
        }
    }

##### 写入zip包 #####

ZipOutputStream是一种FilterOutputStream，它可以直接写入内容到zip包。我们要先创建一个ZipOutputStream，通常是包装一个FileOutputStream，然后，每写入一个文件前，先调用putNextEntry()，然后用write()写入byte\[\]数据，写入完毕后调用closeEntry()结束这个文件的打包。

try (ZipOutputStream zip = new ZipOutputStream(new FileOutputStream(...))) {
        File[] files = ...
        for (File file : files) {
            zip.putNextEntry(new ZipEntry(file.getName()));
            zip.write(getFileDataAsBytes(file));
            zip.closeEntry();
        }
    }

上面的代码没有考虑文件的目录结构。如果要实现目录层次结构，new ZipEntry(name)传入的name要用相对路径。

### 序列化 ###

**序列化是指把一个Java对象变成二进制内容，本质上就是一个byte\[\]数组**  
为什么要把Java对象序列化呢？因为序列化后可以把byte\[\]保存到文件中，或者把byte\[\]通过网络传输到远程，这样，就相当于把Java对象存储到文件或者通过网络传输出去了。  
有序列化，就有**反序列化，即把一个二进制内容（也就是byte\[\]数组）变回Java对象**。有了反序列化，保存到文件中的byte\[\]数组又可以“变回”Java对象，或者从网络上读取byte\[\]并把它“变回”Java对象。  
我们来看看如何把一个Java对象序列化。  
一个Java对象要能序列化，必须实现一个特殊的java.io.Serializable接口，它的定义如下：

public interface Serializable {
    }

Serializable接口没有定义任何方法，它是一个空接口。我们把这样的空接口称为“标记接口”（Marker Interface），实现了标记接口的类仅仅是给自身贴了个“标记”，并没有增加任何方法。

##### 序列化 #####

把一个Java对象变为byte\[\]数组，需要使用ObjectOutputStream。它负责把一个Java对象写入一个字节流：

public class Main {
        public static void main(String[] args) throws IOException {
            ByteArrayOutputStream buffer = new ByteArrayOutputStream();
            try (ObjectOutputStream output = new ObjectOutputStream(buffer)) {
                // 写入int:
                output.writeInt(12345);
                // 写入String:
                output.writeUTF("Hello");
                // 写入Object:
                output.writeObject(Double.valueOf(123.456));
            }
            System.out.println(Arrays.toString(buffer.toByteArray()));
        }
    }

ObjectOutputStream既可以写入基本类型，如int，boolean，也可以写入String（以UTF-8编码），还可以写入实现了Serializable接口的Object。因为写入Object时需要大量的类型信息，所以写入的内容很大。

##### 反序列化 #####

和ObjectOutputStream相反，ObjectInputStream负责从一个字节流读取Java对象：

try (ObjectInputStream input = new ObjectInputStream(...)) {
        int n = input.readInt();
        String s = input.readUTF();
        Double d = (Double) input.readObject();
    }

除了能读取基本类型和String类型外，调用readObject()可以直接返回一个Object对象。要把它变成一个特定类型，必须强制转型。  
readObject()可能抛出的异常有：

*  ClassNotFoundException：没有找到对应的Class；
 *  InvalidClassException：Class不匹配。

对于ClassNotFoundException，这种情况常见于一台电脑上的Java程序把一个Java对象，例如，Person对象序列化以后，通过网络传给另一台电脑上的另一个Java程序，但是这台电脑的Java程序并没有定义Person类，所以无法反序列化。  
对于InvalidClassException，这种情况常见于序列化的Person对象定义了一个int类型的age字段，但是反序列化时，Person类定义的age字段被改成了long类型，所以导致class不兼容。  
为了避免这种class定义变动导致的不兼容，Java的序列化允许class定义一个特殊的serialVersionUID静态变量，用于标识Java类的序列化“版本”，通常可以由IDE自动生成。如果增加或修改了字段，可以改变serialVersionUID的值，这样就能自动阻止不匹配的class版本：

public class Person implements Serializable {
        private static final long serialVersionUID = 2709425275741743919L;
    }

反序列化时，由JVM直接构造出Java对象，不调用构造方法，构造方法内部的代码，在反序列化时根本不可能执行。

##### 安全性 #####

因为Java的序列化机制可以导致一个实例能直接从byte\[\]数组创建，而不经过构造方法，因此，它存在一定的安全隐患。一个精心构造的byte\[\]数组被反序列化后可以执行特定的Java代码，从而导致严重的安全漏洞。实际上，Java本身提供的基于对象的序列化和反序列化机制既存在安全性问题，也存在兼容性问题。更好的序列化方法是通过JSON这样的通用数据结构来实现，只输出基本类型（包括String）的内容，而不存储任何与代码相关的信息。

### Reader ###

Reader是Java的IO库提供的另一个输入流接口。和InputStream的区别是，InputStream是一个字节流，即以byte为单位读取，而Reader是一个字符流，即以char为单位读取：  
![在这里插入图片描述][20200229172319437.png]  
java.io.Reader是所有字符输入流的超类，它最主要的方法是：

public int read() throws IOException;

##### FileReader #####

FileReader是Reader的一个子类，它可以打开文件并获取Reader。下面的代码演示了如何完整地读取一个FileReader的所有字符：

public void readFile() throws IOException {
        // 创建一个FileReader对象:
        Reader reader = new FileReader("src/readme.txt"); // 字符编码是???
        for (;;) {
            int n = reader.read(); // 反复调用read()方法，直到返回-1
            if (n == -1) {
                break;
            }
            System.out.println((char)n); // 打印char
        }
        reader.close(); // 关闭流
    }

##### CharArrayReader #####

CharArrayReader可以在内存中模拟一个Reader，它的作用实际上是把一个char\[\]数组变成一个Reader，这和ByteArrayInputStream非常类似：

try (Reader reader = new CharArrayReader("Hello".toCharArray())) {
    }

##### StringReader #####

StringReader可以直接把String作为数据源，它和CharArrayReader几乎一样：

try (Reader reader = new StringReader("Hello")) {
    }

##### InputStreamReader #####

Reader和InputStream有什么关系？  
除了特殊的CharArrayReader和StringReader，普通的Reader实际上是基于InputStream构造的，因为Reader需要从InputStream中读入字节流（byte），然后，根据编码设置，再转换为char就可以实现字符流。如果我们查看FileReader的源码，它在内部实际上持有一个FileInputStream  
既然Reader本质上是一个基于InputStream的byte到char的转换器，那么，如果我们已经有一个InputStream，想把它转换为Reader，是完全可行的。InputStreamReader就是这样一个转换器，它可以把任何InputStream转换为Reader。示例代码如下：

// 持有InputStream:
    InputStream input = new FileInputStream("src/readme.txt");
    // 变换为Reader:
    Reader reader = new InputStreamReader(input, "UTF-8");

构造InputStreamReader时，我们需要传入InputStream，还需要指定编码，就可以得到一个Reader对象。上述代码可以通过try (resource)更简洁地改写如下：

try (Reader reader = new InputStreamReader(new FileInputStream("src/readme.txt"), "UTF-8")) {
        // TODO:
    }

上述代码实际上就是FileReader的一种实现方式。使用InputStreamReader，可以把一个InputStream转换成一个Reader。

### Writer ###

Reader是带编码转换器的InputStream，它把byte转换为char，而Writer就是带编码转换器的OutputStream，它把char转换为byte并输出。  
Writer和OutputStream的区别如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70 5]  
Writer是所有字符输出流的超类，它提供的方法主要有：

*  写入一个字符（0~65535）：void write(int c)；
 *  写入字符数组的所有字符：void write(char\[\] c)；
 *  写入String表示的所有字符：void write(String s)。

##### FileWriter #####

FileWriter就是向文件中写入字符流的Writer。它的使用方法和FileReader类似：

try (Writer writer = new FileWriter("readme.txt", StandardCharsets.UTF_8)) {
        writer.write('H'); // 写入单个字符
        writer.write("Hello".toCharArray()); // 写入char[]
        writer.write("Hello"); // 写入String
    }

##### CharArrayWriter #####

CharArrayWriter可以在内存中创建一个Writer，它的作用实际上是构造一个缓冲区，可以写入char，最后得到写入的char\[\]数组，这和ByteArrayOutputStream非常类似：

try (CharArrayWriter writer = new CharArrayWriter()) {
        writer.write(65);
        writer.write(66);
        writer.write(67);
        char[] data = writer.toCharArray(); // { 'A', 'B', 'C' }
    }

##### StringWriter #####

StringWriter也是一个基于内存的Writer，它和CharArrayWriter类似。实际上，StringWriter在内部维护了一个StringBuffer，并对外提供了Writer接口。

##### OutputStreamWriter #####

除了CharArrayWriter和StringWriter外，普通的Writer实际上是基于OutputStream构造的，它接收char，然后在内部自动转换成一个或多个byte，并写入OutputStream。因此，OutputStreamWriter就是一个将任意的OutputStream转换为Writer的转换器：

try (Writer writer = new OutputStreamWriter(new FileOutputStream("readme.txt"), "UTF-8")) {
        // TODO:
    }

上述代码实际上就是FileWriter的一种实现方式。这和上一节的InputStreamReader是一样的。

##### PrintStream #####

PrintStream是一种FilterOutputStream，它在OutputStream的接口上，额外提供了一些写入各种数据类型的方法：

*  写入int：print(int)
 *  写入boolean：print(boolean)
 *  写入String：print(String)
 *  写入Object：print(Object)，实际上相当于print(object.toString())
 *  …

以及对应的一组println()方法，它会自动加上换行符。  
我们经常使用的System.out.println()实际上就是使用PrintStream打印各种数据。其中，System.out是系统默认提供的PrintStream，表示标准输出：

System.out.print(12345); // 输出12345
    System.out.print(new Object()); // 输出类似java.lang.Object@3c7a835a
    System.out.println("Hello"); // 输出Hello并换行

System.err是系统默认提供的标准错误输出。  
PrintStream和OutputStream相比，除了添加了一组print()/println()方法，可以打印各种数据类型，比较方便外，它还有一个额外的优点，就是不会抛出IOException，这样我们在编写代码的时候，就不必捕获IOException。

##### PrintWriter #####

PrintStream最终输出的总是byte数据，而PrintWriter则是扩展了Writer接口，它的print()/println()方法最终输出的是char数据。两者的使用方法几乎是一模一样的：

public class Main {
        public static void main(String[] args)     {
            StringWriter buffer = new StringWriter();
            try (PrintWriter pw = new PrintWriter(buffer)) {
                pw.println("Hello");
                pw.println(12345);
                pw.println(true);
            }
            System.out.println(buffer.toString());
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200811100349430.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200811100849228.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200811101719362.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2020081111393529.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200811115741315.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5,size_16,color_FFFFFF,t_70
[20200811103211628.png]: https://img-blog.csdnimg.cn/20200811103211628.png
[20200229171434391.png]: https://img-blog.csdnimg.cn/20200229171434391.png
[20200229172319437.png]: https://img-blog.csdnimg.cn/20200229172319437.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200229172732103.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTM2NDM5,size_16,color_FFFFFF,t_70