吃透Java IO：字节流、字符流、缓冲流

陈建111

已于 2024-03-14 06:09:10 修改

阅读量1.9k

点赞数 3

分类专栏： java NIO java核心知识点整理文章标签： java JAVA IO

于 2021-01-23 11:30:35 首次发布

本文链接：https://blog.csdn.net/chenjian723122704/article/details/112976558

版权

java核心知识点整理同时被 2 个专栏收录

22 篇文章 0 订阅

订阅专栏

java NIO

4 篇文章 0 订阅

订阅专栏

IO流是Java中的一个重要的构成部分，也是我们经常打交道的。

下面几个问题：

Java IO 流有什么特点？
Java IO 流分为几种类型？
字节流和字符流的关系与区别？
缓冲流的效率一定高吗？
缓冲流体现了Java 中哪种设计模式思想？
为什么要实现序列化？如何实现序列化？
序列化数据后，再次修改类文件，读数据会出问题，如何解决呢？

1.初始 Java IO

IO，即 in 和 out，也就是输入和输出，指应用程序和外部设备之间的数据传递，常见的外部设备包括文件、管道、网络连接。

Java 中是通过流处理IO 的，那什么是流？

流（Stream），是一个抽象的概念，是指一连串的数据（字符和字节），是以先进先出的方式发送信息的通道。

当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件、内存、或者是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。

一般来说关于流的特性有下面几点：

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

1.1 IO流分类

IO流主要的分类方式有以下3种：

按数据流的方向：输入流、输出流
按处理数据单位：字节流、字符流
按功能：节点流、处理流

watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5qaWFuNzIzMTIyNzA0,size_16,color_FFFFFF,t_70

1、输入流与输出流

输入与输出是相对于应用程序而言的，比如文件读写，读取文件是输入流，写文件是输出流，这点很容易搞反。

2、字节流与字符流

字节流和字符流的用法几乎完全一样，区别在于字节流和字符流所操作的数据单元不同，字节流操作的单元是数据单元为8位的字节，字符流操作的是数据单位为16位的字符。

为什么要有字符流？

Java中字符是采用Unicode标准，Unicode编码中，一个英文为一个字节，一个中文为两个字节。

watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5qaWFuNzIzMTIyNzA0,size_16,color_FFFFFF,t_70

而在UTF-8编码中，一个中文字符是3个字节。例如下面图中，“云深不知处”5个中文对应的是15字节：-28-70-111-26-73-79-28-72-115-25-97-91-27-92-124

watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5qaWFuNzIzMTIyNzA0,size_16,color_FFFFFF,t_70

那么问题来了，如果使用字节流处理中文，如果一次读写一个字符对应的字节数就不会有问题，一旦将一个字符对应的字节流分裂开来，就会出现乱码。为了方便地处理中文这些字符，Java就退出了字符流。

字节流和字符流的其他区别：

字节流一般用来处理图像、视频、音频、PPT、Word等类型的文件。字符流一般用于处理纯文本类型的文件，如txt文件等，但不能处理图像视频等非文本文件。用一句话说：字节流可以处理一些文件，而字符流智能处理纯文本文件。
字节流本身没有缓冲区，缓冲字节流相对于字节流，效率提升非常高。而字符流本身就带有缓冲区，缓冲字符流相对于字符流效率提升就不是那么大了。详见文末效率对比。

以写文本为例，我们查看字符流的源码，发现确实有利用到缓冲区：

    public void write(String str, int off, int len) throws IOException {
        synchronized (lock) {
            char cbuf[];
            //WRITE_BUFFER_SIZE 缓冲区容量
            //writeBuffer 充当缓冲区的字符数组
            if (len <= WRITE_BUFFER_SIZE) {
                if (writeBuffer == null) {
                    writeBuffer = new char[WRITE_BUFFER_SIZE];
                }
                cbuf = writeBuffer;
            } else {    // Don't permanently allocate very large buffers.
                cbuf = new char[len];
            }
            str.getChars(off, (off + len), cbuf, 0);
            write(cbuf, 0, len);
        }
    }

3、节点流和处理流

节点流：直接操作数据读写的流类，比如 FileInputStream

处理流：对一个已经存在的流的连接和封装，通过对数据进行处理为程序提供功能强大、灵活的读写功能，例如 BufferedInputStream（缓存字节流）

处理流和节点流应用了 Java 的装饰者设计模式。

下图就很形象地描绘了节点流和处理流，处理流是对节点流的封装，最终的数据处理还是由节点流完成的。

watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5qaWFuNzIzMTIyNzA0,size_16,color_FFFFFF,t_70

在诸多的处理流中，有一个非常重要，那就是缓冲流。

我们知道，程序与磁盘的交互相对于内存运算是很慢的，容易成为程序的性能瓶颈。减少程序与磁盘的交互，是提升程序效率一种有效手段。缓冲流，就应用这种思路：普通流每次读写一个字节，而缓冲流在内存中设置一个缓冲区，缓冲区先存储足够的待操作数据后，再与内存或磁盘进行交互。这样，在总数量不变的情况下，通过提高每次交互的数据量，较少了交互次数。

watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5qaWFuNzIzMTIyNzA0,size_16,color_FFFFFF,t_70

联想一下生活中的例子，我们搬砖的时候，一块一块地往车上装肯定是效率很低效的。我们可以使用一个小推车，先把砖装到小推车上，再把这小推车推到车前，把砖撞到车上。这个例子中，小推车可以视为缓冲区，小推车的存在，减少了我们装车的次数，从而提高了效率。

需要注意的是，缓冲流效率一定高吗？不一定，某些情况下，缓冲流效率反而更低，具体请见IO流效率对比。

完整的 IO 分类图如下：

watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5qaWFuNzIzMTIyNzA0,size_16,color_FFFFFF,t_70

1.2 案例实操

接下来，我们看看如何使用Java IO。

文本读写的例子，将“松下问童子，言师采药去。只在此山中，云深不知处。”写入本地文本，然后再从文件读取内容并输出到控制台。

1、FileInputStream、FileOutputStream（字节流）

字节流的方式效率较低，不建议使用

import java.io.*;

public class IOTest {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/test.txt");

        write(file);
        System.out.println(read(file));
    }

    private static void write(File file) throws IOException {
        OutputStream os = new FileOutputStream(file);
        //要写入的字符串
        String str = "松下问童子，言师采药去。只在此山中，云深不知处。";
        //写入文件
        os.write(str.getBytes("UTF-8"));
        //关闭流
        os.close();
    }

    private static String read(File file) throws IOException {
        InputStream is = new FileInputStream(file);
        //一次性取多少字节
        byte[] bytes = new byte[1024];
        //用来接收读取的字节数组
        StringBuffer sb = new StringBuffer();
        //读取到的字节数组长度，为-1时表示没有数据
        int length = 0;
        //循环读取
        while ((length = is.read(bytes)) != -1) {
            //将读取内容转出字符串
            sb.append(new String(bytes,0,length,"UTF-8"));
        }
        //关闭流
        is.close();
        return sb.toString();
    }
}

2、BufferedInputStream、BufferedOutputStream（缓冲字节流）

缓冲字节流是为高效而设计的，真正的读写操作还是靠FileInputStream和FileOutputStream，所以其构造方法入参是这两个类的对象也就不奇怪了。

import java.io.*;

public class IOTest {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/test.txt");

        write(file);
        System.out.println(read(file));
    }

    private static void write(File file) throws IOException {
        //缓存字节流，提高了效率
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file));
        //要写入的字符串
        String str = "松下问童子，言师采药去。只在此山中，云深不知处。";
        //写入文件
        bos.write(str.getBytes("UTF-8"));
        //关闭流
        bos.close();
    }

    private static String read(File file) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
        //一次性取多少字节
        byte[] bytes = new byte[1024];
        //用来接收读取的字节数组
        StringBuffer sb = new StringBuffer();
        //读取到的字节数组长度，为-1时表示没有数据
        int length = 0;
        //循环读取
        while ((length = bis.read(bytes)) != -1) {
            //将读取内容转出字符串
            sb.append(new String(bytes,0,length,"UTF-8"));
        }
        //关闭流
        bis.close();
        return sb.toString();
    }
}

3、InputStreamReader和OutputStreamWriter（字符流）

字符流适用于文本文件的读写，OutputStreamWriter类其实也是借助FileOutputStream类实现的，故其构造方法是FileOutputStream对象

import java.io.*;

public class IOTest {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/test.txt");

        write(file);
        System.out.println(read(file));
    }

    private static void write(File file) throws IOException {
        //OutputStreamWriter可以显示的指定字符集，否则使用默认字符集
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
        //要写入的字符串
        String str = "松下问童子，言师采药去。只在此山中，云深不知处。";
        //写入文件
        osw.write(str);
        //关闭流
        osw.close();
    }

    private static String read(File file) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"UTF-8");
        //字符数组：一次性读取多少个字符
        char[] chars = new char[1024];
        //用来接收读取的数组
        StringBuffer sb = new StringBuffer();
        //读取到的字节数组长度，为-1时表示没有数据
        int length = 0;
        //循环读取
        while ((length = isr.read(chars)) != -1) {
            //将读取内容转出字符串
            sb.append(chars,0,length);
        }
        //关闭流
        isr.close();
        return sb.toString();
    }
}

4、字符流便捷类

Java提供了 FileWriter和FileReader简化字符流的读写，new FileWriter 等同于 new OutputStreamWriter(new FileOutputStream(file))

import java.io.*;

public class IOTest {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/test.txt");

        write(file);
        System.out.println(read(file));
    }

    private static void write(File file) throws IOException {
        FileWriter fw = new FileWriter(file);
        //要写入的字符串
        String str = "松下问童子，言师采药去。只在此山中，云深不知处。";
        //写入文件
        fw.write(str);
        //关闭流
        fw.close();
    }

    private static String read(File file) throws IOException {
        FileReader fr = new FileReader(file);
        //字符数组：一次性读取多少个字符
        char[] chars = new char[1024];
        //用来接收读取的数组
        StringBuffer sb = new StringBuffer();
        //读取到的字节数组长度，为-1时表示没有数据
        int length = 0;
        //循环读取
        while ((length = fr.read(chars)) != -1) {
            //将读取内容转出字符串
            sb.append(chars,0,length);
        }
        //关闭流
        fr.close();
        return sb.toString();
    }
}

5、BufferedReader、BufferedWriter（字符缓冲流）

import java.io.*;

public class IOTest {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/test.txt");

        write(file);
        System.out.println(read(file));
    }

    private static void write(File file) throws IOException {
        // BufferedWriter fw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF-8"));
        // FileWriter可以大幅度简化代码
        BufferedWriter bw = new BufferedWriter(new FileWriter(file));
        //要写入的字符串
        String str = "松下问童子，言师采药去。只在此山中，云深不知处。";
        //写入文件
        bw.write(str);
        //关闭流
        bw.close();
    }

    private static String read(File file) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(file));
        //用来接收读取的数组
        StringBuffer sb = new StringBuffer();
        //按行读数据
        String line;
        //循环读取
        while ((line = br.readLine()) != null) {
            sb.append(line);
        }
        //关闭流
        br.close();
        return sb.toString();
    }
}

2.IO 流对象

第一节中，我们大致了解了IO，并完成了几个案例，但对IO还缺乏更详细的认知，那么接下来我们就对JavaIO细细分解，梳理出完整的知识体系来。

Java中提供了40多个类，我们只需要详细了解一下其中比较重要的就可以满足日常应用了。

2.1 File类

File类是用来操作文件的类，但它不能操作文件中的数据。

public class File implements Serializable, Comparable<File>

File类实现了Serializable、 Comparable<File>，说明它是支持序列化和排序的。

File类的构造方法

方法名	说明
File(File parent, String child)	根据parent抽象路径名和child路径名字符串创建一个新的File实例
File(String pathname)	通过将给定路径名字符串转为抽象路径名来创建一个新的File实例
File(String parent, String child)	根据parent路径名字符串和child路径名字符串创建一个新的File实例
File(URI uri)	通过给定的file:URI 转为一个抽象路径名来创建一个新的File实例

File类的常用方法

方法名	说明
createNewFile()	当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
delete()	删除此抽象路径名表示的文件或目录
exists()	册数此抽象路径名表示的文件或目录是否存在
getAbsoluteFile()	返回此抽象路径名的绝对路径名形式。
getAbsolutePath()	返回此抽象路径的绝对路径名字符串。
length()	返回此抽象路径表示的文件的长度。
mkdir()	创建此抽象路径名指定的目录。

File类使用实例

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

public class FileTest {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/test.txt");
        //判断文件是否存在
        if (!file.exists()) {
            //不存在则创建
            file.createNewFile();
        }
        System.out.println("文件的绝对路径："+file.getAbsolutePath());
        System.out.println("文件的大小：" + file.length());
        //删除文件
        file.delete();
    }
}

2.2 字节流

InputStream和OutputStream是两个抽象类，是字节流的基类，所有具体的字节流实现都是分别继承了这两个类。

以InputStream为例，实现了Closeable

public abstract class InputStream implements Closeable

InputStream类有很多的实现子类，下面列举了一些比较常用的：

watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5qaWFuNzIzMTIyNzA0,size_16,color_FFFFFF,t_70

详细说明下上图中的类：

InputStream：InputStream是所有字节输入流的抽象基类，前面说过抽象类不能被实例化，实际上是作为模板而存在的，为所有实现类定义了处理输入流的方法。
FileInputStream：文件输入流，一个非常重要的字节输入流，用于对文件进行读取操作。
PipedInputStream：管道字节输入流，能实现多线程间的管道通讯。
ByteArrayInputStream：字节数组输入流，从字节数组（byte[]）中进行以字节为单位的读取，也就是将资源文件都已字节的形式存入到该类的字节数组中去。
FilterInputStream：装饰者类，具体装饰者集成该类，这些都是处理类，作用是对节点类进行封装，实现一些特殊功能。
DataInputStream：数据输入流，它是用来装饰其他输入流，作用是“允许应用程序以与机器无关方式从底层输入流中读取基本Java数据类型”。
BufferedInputStream：缓冲流，对节点流进行装饰，内部会与一个缓存区，用来存放字节，每次都将缓存区存满后发送，而不是一个字节或两个字节这样发送，效率更高。
ObjectInputStream：对象输入流，用来提供对基本数据或对象的持久存储。通俗的说，也就是能直接传输对象，通常应用在反序列化中。它也是一种处理流，构造器的入参是一个InputStream对象。

OutputStream类继承关系图：

watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5qaWFuNzIzMTIyNzA0,size_16,color_FFFFFF,t_70

OutputStream类继承关系与InputStream类型，需要注意的是PrintStream。

2.3 字符流

与字节流类似，字符流也有两个抽象基类，分别是Reader和Writer。其他的字符流实现类都是继承了这两个类。

以Reader为例，它的主要实现子类如下图：

watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5qaWFuNzIzMTIyNzA0,size_16,color_FFFFFF,t_70

各个类的详细说：

InputStreamReader：从字节流到字符流的桥梁（InputStreamReader构造器入参是FileInputStream的实例对象），它读取字节并使用指定的字符集将其解码为字符。它是由的字符集可通过名称指定，也可以显示给定，或者可以接收平台的默认字符集。
BufferedReader：从字符输入流中读取文本，设置一个缓存区来提高效率。BufferedReader是对InputStreamReader的封装，前者构造器的入参就是后者的一个实例对象。
FileReader：用于读取字符文件的便利类，new FileReader(File file)等同于new InputStreamReader(new FileInputStream(file),"UTF-8")，但FileReader不能指定指定字符编码和默认缓冲区大小。
PipedReader：管道字符输入流。实现多线程间的管道通信。
CharArrayReader：从Char数组中读取数据的介质流。
StringReader：从String中读取数据的介质流。

Writer与Reader结构类似，方向相反，不在赘述。唯一有区别的是，Writer的子类PrintWriter。

2.4 序列化

序列化：指堆内存中的Java对象，通过某种方式把对像存储到磁盘文件中，或者传递给其他网络节点（网络传输）。这个过程称为序列化，通常是指将数据结构或对象转成二进制的过程。

反序列化：把磁盘文件中的对象数据或把网络节点上的对象数据，恢复成Java对象模型的过程。也就是将在序列化过程中生成的二进制串转成数据结构或对象的过程。

序列化的作用

想把内存中的对象保存到一个文件中或者数据库中的时候。
想用套接字在网络上传送对象的时候；
想通过RMI传输对象的时候。

序列化实现

要实现对象的序列化，最直接的操作就是实现Serializable接口。使用IO流对象可以实现序列化操作，将对象保存到文件中，再读取出来。

import java.io.*;

public class ObjectTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        File file = new File("D:/obj.txt");
        User user = new User("宝宝",12);
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
        oos.writeObject(user);
        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        Object obj = ois.readObject();
        ois.close();
        System.out.println(obj);
    }

    public static class User implements Serializable {
        private static final long serialVersionUID = 1L;
        private String name;
        private int age;

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

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

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

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

        @Override
        public String toString() {
            return "User[name="+name+",age="+age+"]";
        }
    }
}

这里我们成功的进行了一次将对象保存到文件中，在读取了出来。如果此时，我们不实现序列化接口，就会出现异常了。

Exception in thread "main" java.io.NotSerializableException: ObjectTest$User
   at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
   at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
   at ObjectTest.main(ObjectTest.java:8)

可以看到，因为没有进行序列化，所以无法保存与读取。

序列化ID的作用

可以看到，我们在进行序列化是，加了一个serialVersionUID字段，这边是序列化ID

private static final long serialVersionUID = 1L;

这个序列化ID起着关键的作用，它决定这是否能否成功反序列化！Java的序列化机制是通过判断运行时类的serialVersionUID来验证版本一致性的，在进行反序列化时，JVM会把传进来的字节流中的serialVersionUID与本地实体类的serialVersionUID进行比较，如果相同则认为一致的，便可以进行反序列化，否则就会报序列化版本不一致的异常。

默认序列化ID

当我们一个实体类中没有显示定义一个名为 serialVersionUID 、类型为 long的变量时，Java序列化机制会根据编译时的class自动生成一个serialVersionUID。例如，当我们在本地类中添加其他的字段，这个时候再反序列化时便会出现serialVersionUID不一致，导致反序列化失败。那么怎么解决呢？便是在本地类中添加一个 long 类型的名称为 “serialVersionUID ” 的变量，值保持不变，便可以进行序列化和反序列化。

如果没有显示指定 serialVersionUID，会自动生成一个。
只有同一次编译的class才会生成相同的serialVersionUID
但如果出现需求变动,Bean类发生改变,则会导致发序列化失败.为了不出现类似的问题,所以我们最好还是显示的指定一个serialVersionUID.

序列化的其他问题

静态变量不会被序列化.(static, transient)

当一个父类实现序列化,子类自动实现序列化,不需要显示地实现Serializable接口.

当一个对象的实例变量引用其他对象,序列化该对象时也把引用对象进行序列化.

子类序列化时：

如果父类没有实现Serializable接口，没有提供默认构造函数，那么子类的序列化会出错；

如果父类没有实现Serializable接口，提供了默认的构造函数，那么子类可以序列化，父类的成员变量不会被序列化。如果父类实现了Serializable接口，则父类和子类都可以序列化。

3. IO流方法

3.1 字节流方法

字节输入流 InputStream 主要方法：

read()：从此输入流中读取一个数据字节
read(byte[] b)：从此输入流中将最多 b.length个字节的数据读入一个byte数组中
read(byte[], int off, int len)：从此输入流中将最多len个字节的数据读入一个byte数组中
close()：关闭输入流并释放与该流关联的所有资源

字节输出流 OutputStream 主要方法：

write(byte[] b)：将b.length 个字节从指定byte数组写入此文件输出流中
write(byte[] b, int off, int len)：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流
write(int b)：将指定字节写入此文件输出流
close()：关闭输入流并释放与该流关联的所有资源

3.2 字符流方法

字符输入流 Reader 主要方法：

read()：读取单个字符
read(char[] cbuf)：将字符读入数组
read(char[] cbuf, int off, int len)：将字符读入数组的某一部分
read(CharBuffer target)：视图将字符读入指定的字符缓冲区
flush()：刷新该流的缓冲
close()：关闭此流，但要先刷新它

字符输出流 Writer 主要方法：

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

另外，字符缓冲流还有两个独特的方法：

BufferedWriter 类 newLine()：写入一个行分隔符。这个方法会自动适配所在系统的行分隔符。
BufferedReader 类 readLine()：读取一个文本行

4.附加内容

4.1 位、字节、字符

字节（Byte）是计量单位，表示数据量多少，是计算机信息技术用于存储容量的一种计量单位，通常情况下一字节等于8位。

字符（Character）计算机中使用的字母、数组、和符号，比如‘A’、‘B’、‘$’、‘&’等。

一般在英文状态下一个字母或字符占用一个字节，一个汉字用两个字节表示。

字节与字符：

ASCII码中，一个英文字母（不分大小写）为一个字节，一个中文汉字为两个字节。
UTF-8 编码中，一个英文字为一个字节，一个中文为三个字节。
Unicode 编码中，一个英文字为一个字节，一个中文为两个字节。
符号：英文标点为一个字节，中文标点为两个字节。例如：英文句号“.”占一个字节大小，中文句号"。"栈两个字节大小。
UTF-16 编码中，一个英文字母或一个汉字都需要2字节存储（Unicode 扩展区的一些汉字存储需要4个字节）
UTF-32编码中，世界上任何字符的存储都需要4个字节。

4.2 IO流效率对比

首先，对比下普通字节流和缓存字节流的效率：

import java.io.*;

public class MyTest {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/myTest.txt");
        StringBuilder sb = new StringBuilder();

        for (int i=0; i<3000000; i++) {
            sb.append("abcdefghigklmnopqrstuvwsyz");
        }

        byte[] bytes = sb.toString().getBytes();

        long start = System.currentTimeMillis();
        write(file, bytes);
        long end = System.currentTimeMillis();


        long start2 = System.currentTimeMillis();
        bufferedWrite(file, bytes);
        long end2 = System.currentTimeMillis();

        System.out.println("普通字节流耗时：" + (end - start) + " ms");
        System.out.println("缓冲字节流耗时：" + (end2 - start2) + " ms");
    }

    private static void write(File file, byte[] bytes) throws IOException {
        OutputStream os = new FileOutputStream(file);
        os.write(bytes);
        os.close();
    }

    private static void bufferedWrite(File file, byte[] bytes) throws IOException {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file));
        bos.write(bytes);
        bos.close();
    }
}

运行结果：

普通字节流耗时：81 ms
缓冲字节流耗时：80 ms

这个结果让我大跌眼镜，不是说好缓冲流效率很高么？要知道为什么，智能去源码里找答案了。看了字节缓存流 write() 方法：

    public synchronized void write(byte b[], int off, int len) throws IOException {
        if (len >= buf.length) {
            /* If the request length exceeds the size of the output buffer,
               flush the output buffer and then write the data directly.
               In this way buffered streams will cascade harmlessly. */
            flushBuffer();
            out.write(b, off, len);
            return;
        }
        if (len > buf.length - count) {
            flushBuffer();
        }
        System.arraycopy(b, off, buf, count, len);
        count += len;
    }

注释里说的很明白：如果请求长度超过缓冲区大小，刷新输出缓冲流，然后直接写入数据。这样，缓冲流将无害地级联。

但是，至于为什么这么设计，我没想明白。

基于上面的情形，想要对比普通字节流和缓冲字节流的效率差距，就要避免直接写较长的字符串，于是修改了上面的案例：

import java.io.*;

public class MyTest {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/myTest.txt");
        StringBuilder sb = new StringBuilder();

        for (int i=0; i<30000; i++) {
            sb.append("abcdefghigklmnopqrstuvwsyz");
        }

        byte[] bytes = sb.toString().getBytes();

        long start = System.currentTimeMillis();
        write(file, bytes);
        long end = System.currentTimeMillis();


        long start2 = System.currentTimeMillis();
        bufferedWrite(file, bytes);
        long end2 = System.currentTimeMillis();

        System.out.println("普通字节流耗时：" + (end - start) + " ms");
        System.out.println("缓冲字节流耗时：" + (end2 - start2) + " ms");
    }

    private static void write(File file, byte[] bytes) throws IOException {
        OutputStream os = new FileOutputStream(file);
        for (int i=0;i<bytes.length;i++){
            os.write(bytes[i]);
        }
        os.close();
    }

    private static void bufferedWrite(File file, byte[] bytes) throws IOException {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file));
        for (int i=0;i<bytes.length;i++){
            bos.write(bytes[i]);
        }
        bos.close();
    }
}

运行结果：

普通字节流耗时：1565 ms
缓冲字节流耗时：21 ms

这次，普通字节流和缓冲字节流的效率差异就很明显了。

在看看字符流和缓冲字符流的效率对比：

import java.io.*;

public class MyTest2 {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/myTest.txt");
        StringBuilder sb = new StringBuilder();

        for (int i=0; i<300000; i++) {
            sb.append("abcdefghigklmnopqrstuvwsyz");
        }

        byte[] bytes = sb.toString().getBytes();

        long start = System.currentTimeMillis();
        write(file, bytes);
        long end = System.currentTimeMillis();


        long start2 = System.currentTimeMillis();
        bufferedWrite(file, bytes);
        long end2 = System.currentTimeMillis();

        System.out.println("普通字符流耗时：" + (end - start) + " ms");
        System.out.println("缓冲字符流耗时：" + (end2 - start2) + " ms");
    }

    private static void write(File file, byte[] bytes) throws IOException {
        Writer writer = new FileWriter(file);
        for (int i=0;i<bytes.length;i++){
            writer.write(bytes[i]);
        }
        writer.close();
    }

    private static void bufferedWrite(File file, byte[] bytes) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter(file));
        for (int i=0;i<bytes.length;i++){
            bw.write(bytes[i]);
        }
        bw.close();
    }
}

运行结果：

普通字符流耗时：283 ms
缓冲字符流耗时：204 ms

测试多次，结果差不多，可见字符缓冲流效率是并没有明显提高，我们更多的是要适应它们的 readLine() 和 writeLine() 方法。

陈建111

关注

3
点赞
踩
12

收藏

觉得还不错? 一键收藏
3
评论
吃透Java IO：字节流、字符流、缓冲流

IO流是Java中的一个重要的构成部分，也是我们经常打交道的。下面几个问题：Java IO 流有什么特点？ Java IO 流分为几种类型？字节流和字符流的关系与区别？缓冲流的效率一定高吗？缓冲流体现了Java 中哪种设计模式思想？为什么要实现序列化？如何实现序列化？序列化数据后，再次修改类文件，读数据会出问题，如何解决呢？1.初始 Java IOIO，即 in 和 out，也就是输入和输出，指应用程序和外部设备之间的数据传递，常见的外部设备包括文件、管道、网络连接。
复制链接

扫一扫

专栏目录