Java IO 一直以来是大厂面试题中的高频考点，本文将从 Java IO 基础使用说起，以案例 + 源码的方式讲解文件、字节流、字符流、缓冲流、打印流、随机访问流等基础内容，再深入到 Java IO 模型与设计模式，从而构建出对 Java IO 的全面认知。

文章不仅适合完全不了解 Java IO 的新同学，也适合具备一定知识储备的老同学。文中的所有案例代码强烈推荐手写复现一遍，以更好地掌握 Java IO 编程基础。

(资料图片)

文章的结尾处给出了更新日志，每次新更新的内容都会写明，便于同学们快速了解更新的内容是否是自己所需要的知识点。

我相信，友好的讨论交流会让彼此快速进步！文章难免有疏漏之处，十分欢迎大家在评论区中批评指正。

文件

文件在程序中是以流的形式来操作的。类关系如下：

创建文件

常用构造方法

要想真正地在磁盘中创建文件，需要执行 createNewFile() 方法。

Tips

所有 中的类的 相对路径 默认都是从 用户工作目录 开始的，使用 ("") 可以获取你的用户工作目录。 在 Windows 系统中的分隔符为 "\"，在 Linux 系统中分隔符为 "/"，为了保证系统的可移植性，可以通过常量字符串 获取(参见案例中的使用)。

使用案例

java复制代码@Testpublic void createFile() {    // 更换成你想要存放的文件路径，默认情况为用户工作目录，可以通过 ("") 显示获取    String userDir = ("");    ("用户工作目录：" + userDir);    ("当前操作系统的文件分隔符为：" + );    String fileName = "";    String path = userDir +  + fileName; // 组装路径    File file = new File(path); // 此时只是程序中的一个对象    // File file = new File(fileName); // 默认会创建到用户工作目录中，和上一面的语句创建的文件路径一致。    try {        (); // 执行该方法才会真正地在磁盘中创建文件        ("文件创建成功");    } catch (IOException e) {        ();    }}

java复制代码@Testpublic void createFile2() {    // 更换成你想要存放的文件路径    File parentFile = new File("/Users/sunnywinter/projects/interviewcode/");    String fileName = "";    File file = new File(parentFile, fileName);    try {        ();        ("文件创建成功");    } catch (IOException e) {        ();    }}

java复制代码@Testpublic void createFile3() {    // 更换成你想要存放的文件路径    String parentFile = ("");    String fileName = "";    File file = new File(parentFile, fileName);    try {        ();        ("文件创建成功");    } catch (IOException e) {        ();    }}

获取文件信息

常用方法

使用案例

java复制代码@Testpublic void getFileInfo() {    File file = new File("/Users/sunnywinter/projects/interviewcode/");    ("文件名：" + ());    ("文件绝对路径：" + ());    ("文件父级目录：" + ());    ("文件大小(字节)：" + ());    ("文件是否存在：" + ());    ("是否是一个文件：" + ());    ("是否是一个目录：" + ());}

目录操作与文件删除

使用方法

使用案例

java复制代码@Testpublic void test() {    String parentPath = "/Users/sunnywinter/projects/interviewcode/";    String fileName = "";    String directoryName = "a";    String mulDirectoryName = "b/c/d";    // 删除文件    File file = new File(parentPath, fileName);    ();    // 创建一级目录    File directory = new File(parentPath, directoryName);    ();    // 创建多级目录    File mulDirectory = new File(parentPath, mulDirectoryName);    ();    // 删除目录    ();}

IO 流概述

IO，Input/Output，即输入/输出。判断输入输出以计算机内存为中心，如果从内存到外部存储就是输出，从外部存储到内存就是输入。数据传输过程类似于水流，因此称为 IO 流。

在 Java 中，根据操作数据单位的不同，IO 流分为字节流和字符流；根据数据流的流向不同，分为输入流和输出流；根据流的角色不同，分为节点流和处理流。

Java IO 流共涉及 40 多个类，但都是从表中的 4 个抽象基类派生而来，派生的子类名称都是以其父类名作为子类名的后缀。

列举一些常用的类。

字节流

首先，我们先学习如何将数据写入到文件中。

OutputStream(字节输出流)

OutputStream 用于将内存数据(字节信息)写入到文件中，抽象类是所有字节输出流的父类。

常用方法

FileOutputStream

FileOutputStream 是最常用的字节输出流子类，可直接指定文件路径，可以直接输出单字节数据，也可以输出指定的字节数组。

类图关系如下：

Tips

接口扩展了 接口。因此，对任何 Closeable 进行操作时，都可以使用 try-with-resource 语句（声明了一个或多个资源的 try 语句，可以自动关闭流，具体使用方法参见使用案例）。 为什么要有两个接口呢？因为 Closeable 接口的 close 方法只抛出了 IOException，而 方法可以抛出任何异常。

常用构造函数

append 为 true 时，表明追加写入。

使用案例

需求 1：向 文件中写入 Hi,Mrpersimmon!

代码：

java复制代码@Testpublic void testFileOutputStream() {    // FileOutputStream(String name, boolean append) 追加写入    // FileOutputStream(String name) 覆盖写入    try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(""))) {        String str = "Hi,Mrpersimmon!";        // write(byte b[]) : 将字节数组 b 写入到输出流，等价于 write(b, 0, )        (("UTF-8")); // () 字符串 ->字节数组    } catch (IOException e) {        ();    }}

Tips

FileOutputStream 在使用中要和 BufferedOutputStream 一起使用，性能更好。 try(...OutputStream) 可以自动关闭输出流，无需 try-finally 手动关闭。

运行结果：

DataOutputStream

DataOutputStream 用于写入指定类型数据，不能单独使用，必须结合 FileOutputStream，构造函数源码如下：

类图关系如下：

使用案例

需求：向 写入 Hi,Mrpersimmon!

代码：

java复制代码@Testpublic void testDataOutputStream() {    try (DataOutputStream dos = new DataOutputStream(new FileOutputStream(""))) {        // 输出任意输入类型        ("Hi,Mrpersimmon!");    } catch (IOException e) {        ();    }}

运行结果：

ObjectOutputStream

ObjectOutputStream 用于将对象写入到输出流(序列化)。与之相对反地，ObjectInputStream 用于从输入流中读取 Java 对象(反序列化)。

类图关系如下：

序列化与反序列化

什么是序列化和反序列化？ 序列化就是在保存数据时，保存数据的值和数据类型；反序列化就是在恢复数据时，恢复数据的值和数据类型。

如何让类支持序列化机制呢？ 必须让类实现 Serializable 接口(一个标记接口，没有方法)或者 Externalizable 接口(有方法需要实现)。如果类中有属性不想被序列化，需要使用 transient 修饰。

注意事项

使用案例

需求：创建一个支持序列化的 Blog 类，向 写入一个 Blog 对象。

代码：

Blog 类

java复制代码public class Blog implements Serializable {    private static final long serialVersionUID = -4970674810941727545L;    String name;    String url;    public Blog(String name, String url) {         = name;         = url;    }    @Override    public String toString() {        return "Blog{" +                "name="" + name + "\"" +                ", url="" + url + "\"" +                "}";    }}

功能代码

java复制代码@Testpublic void testObjectOutputStream() {    try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(""))) {        Blog blog = new Blog("mrpersimmon", "");        (blog);        ("数据写入完成(序列化)");    } catch (IOException e) {        ();    }}

运行结果

下面我们来学习如何从文件中读取数据信息。

InputStream(字节输入流)

InputStream 用于从文件读取数据(字节信息)到内存中， 抽象类是所有字节输入流的父类。

常用方法

FileInputStream

FileInputStream 是一个比较常用的字节输入流子类，可 直接指定文件路径 ，可以 直接读取单字节数据 ，也可以 读取至字节数组中 。

类图关系如下：

使用案例

需求：读取 文件，并将文件内容显示到控制台中。

方法 1：使用 read() 单个字节读取，效率较低。

代码：

java复制代码@Testpublic void testFileInputStream() {    // try() 会自动关闭输入流，FileInputStream 与 BufferedInputStream 配合使用    try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(""))) {        // int available() 返回输入流中可以读取的字节数。        ("文件中可读取的字节数量：" + ());        // long skip(long n) 忽略输入流中的 n 个字节 ,返回实际忽略的字节数。        long skipCounts = (3); // 忽略 3 个字节        ("忽略的字节数量：" + skipCounts);        // read() 返回输入流中下一个字节的数据。        ("从文件中读取的字节内容：");        int content;        // 返回值为 -1 时，表示读取完毕        while ((content = ()) != -1) {            ((char) content); // 将读出的 int 类型数据强转成 char 类型        }    } catch (IOException e) {        ();    }}

Tips

FileInputStream 在使用中要和 BufferedInputStream 一起使用，性能更好。 try(...InputStream) 可以自动关闭输入流，无需 try-finally 手动关闭。

运行结果：

复制代码文件中可读取的字节数量：15忽略的字节数量：3从文件中读取的字节内容：Mrpersimmon!

方法 2：使用 read(byte[] b) 读取文件，提高效率。

代码：

java复制代码@Testpublic void testFileInputStream2() {    // try() 会自动关闭输入流，FileInputStream 与 BufferedInputStream 配合使用    try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(""))) {        // int available() 返回输入流中可以读取的字节数。        int bufSize = ();        ("文件中可读取的字节数量：" + bufSize);        byte[] buf = new byte[8]; // 一次读取 8 字节        // long skip(long n) 忽略输入流中的 n 个字节 ,返回实际忽略的字节数。        long skipCounts = (3); // 忽略 3 个字节        ("忽略的字节数量：" + skipCounts);        // read(byte b[]) 从输入流中读取一些字节存储到数组 b 中。        // 如果数组 b 的长度为零，则不读取。        // 如果没有可用字节读取，返回 -1。        // 如果有可用字节读取，则最多读取的字节数最多等于 ，返回读取的字节数。        // 这个方法等价于 read(b, 0, )。        ("从文件中读取的字节内容：");        int readLen;        // 返回值为 -1 时，表示读取完毕        while ((readLen = (buf)) != -1) {            (new String(buf, 0, readLen)); // 将字符数组 buf 转换成字符串        }    } catch (IOException e) {        ();    }}

运行结果：

复制代码文件中可读取的字节数量：15忽略的字节数量：3从文件中读取的字节内容：Mrpersimmon!

DataInputStream

DataInputStream 用于读取指定类型数据，不能单独使用，必须结合 InputStream 的一个实现类使用，构造函数源码如下：

类图关系如下：

使用案例

需求：读取 文件，并将文件内容显示到控制台中。

代码

java复制代码@Testpublic void testDataInputStream() throws IOException {    // 必须将一个 InputStream 的实现类作为构造参数才能使用    try(DataInputStream dis = new DataInputStream(new FileInputStream(""))) {        // 可以读取任意具体的类型数据        (()); // 读取已使用 modified UTF-8 格式编码的字符串。    } catch (IOException e) {        ();    }}

运行结果

复制代码Hi,Mrpersimmon!

ObjectInputStream

ObjectInputStream 用于从输入流中读取 Java 对象（反序列化）。

类图关系如下：

使用案例

需求：读取 中的 Blog 对象。

代码

java复制代码@Testpublic void testObjectInputStream() {    try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(""))) {        (());        ("数据读取完毕(反序列化完成)");    } catch (IOException e) {        ();    } catch (ClassNotFoundException e) {        throw new RuntimeException(e);    }}

运行结果

ini复制代码Blog{name="mrpersimmon", url=""}数据读取完毕(反序列化完成)

综合案例

需求

完成图片的拷贝。

代码

java复制代码@Testpublic void testCopyPic() {    String srcPicPath = "";    String destPicPath = "";    try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcPicPath));         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destPicPath))) {        byte[] buf = new byte[1024];        int readLen = 0;        while ((readLen = (buf)) != -1) {            // bis 输入流从源图片文件读取数据后，写入到 bos 输出流的目标文件地址            (buf, 0, readLen);        }    } catch (IOException e) {        ();    }}

字符流

字符流与字节流的对比

为什么 I/O 流操作要分为字节流操作和字符流操作呢？

何时使用字节流，何时使用字符流？

如果是音频文件、图片等媒体文件使用用字节流会有更好的性能优势；

如果涉及到字符的话(如，文本文件等)使用字符流比较好。

常用字符编码所占字节数？

字符流默认采用的是 Unicode 编码，我们可以通过构造方法自定义编码。

utf8，英文占 1 字节，中文占 3 字节；

unicode：任何字符都占 2 个字节；

gbk：英文占 1 字节，中文占 2 字节。

Writer(字符输出流)

Writer用于将内存数据(字符信息)写入到文件，抽象类是所有字符输出流的父类。

常用方法

FileWriter

OutputStreamWriter 是字符流转换为字节流的桥梁，其子类 FileWriter 是基于该基础上的封装，可以直接将字符写入到文件。

类图如下：

使用案例

代码

java复制代码@Testpublic void testFileWriter() {    String filePath = "";    try (BufferedWriter bw = new BufferedWriter(new FileWriter(filePath))) {        ("Hi,Mrpersimmon!");        ("
"); // 添加换行符        ("欢迎你来到柿子博客".toCharArray(), 0, 3); // toCharArray 可以将字符串转换成字符数组        ("
");        ("欢迎你来到柿子博客", 3, 6);    } catch (IOException e) {        ();    }}

Tips

FileWriter 要和 BufferedWriter 一起使用，性能更好； 一定要关闭输出流或者 flush ，否则无法写入到文件中。

运行结果

Reader(字符输入流)

Reader用于从文件读取数据(字符信息)到内存中，抽象类是所有字符输入流的父类。

常用方法

FileReader

InputStreamReader 是字节流转换为字符流的桥梁，其子类 FileReader 是基于该基础上的封装，可以直接操作字符文件。

类图关系如下：

使用案例

需求 ：读取 中的信息

代码

java复制代码@Testpublic void testFileReader1() {    try (BufferedReader br = new BufferedReader(new FileReader(""))) {        char[] cbuf = new char[8];        int readLen = 0;        while ((readLen = (cbuf)) != -1) {            (new String(cbuf, 0, readLen));        }    } catch (IOException e) {        ();    }}

运行结果

复制代码Hi,Mrpersimmon!欢迎你来到柿子博客

字节/字符缓冲流

IO 操作是很消耗性能的，缓冲流将数据加载至缓冲区，一次性读取/写入多个字节/字符，从而避免频繁的 IO 操作，提高流的传输效率。

字节缓冲流这里采用了 装饰器模式 来增强 InputStream 和OutputStream子类对象的功能。字符缓冲流同理。

常见的使用方式已在上面的使用案例中给出，使用方式如下：

java复制代码BufferedReader br = new BufferedReader(new FileReader(""))

字节流和字节缓冲流性能对比

字节流和字节缓冲流的性能差别主要体现在调用 write(int b) 和 read() 这两种一次只写入/读取一个节点的方式时。由于 字节缓冲流内部有缓冲区(字节数组) ，因此， 字节缓冲流会先将读取到的字节存放在缓存区 ，大幅减少 IO 次数，提高读取效率。

测试对比 1（单字节处理）

分别使用字节流和字节缓冲流的方式复制一个 207 MB 的 PDF 文件，查看耗时对比。

代码

1. 使用字节流复制 PDF 文件

java复制代码@Testpublic void copyFileByStream() {    ("使用字节流复制 PDF 文件测试开始");    long startTime = (); // 记录开始时间    String srcPath = "/Users/sunnywinter/Downloads/深入剖析";    String destPath = "/Users/sunnywinter/Downloads/深入剖析";    try (FileInputStream fis = new FileInputStream(srcPath);         FileOutputStream fos = new FileOutputStream(destPath)) {        int content = 0;        while ((content = ()) != -1) {            (content);        }    } catch (IOException e) {        ();    }    long endTime = (); // 记录结束时间    ("使用字节流复制 PDF 文件总耗时 " + (endTime - startTime) + " 毫秒");}

2. 使用缓冲字节流复制 PDF 文件

java复制代码@Testpublic void copyFileByBufferStream() {    ("使用缓冲字节流复制 PDF 文件测试开始");    long startTime = (); // 记录开始时间    // 文件大小 207 MB    String srcPath = "/Users/sunnywinter/Downloads/深入剖析";    String destPath = "/Users/sunnywinter/Downloads/深入剖析";    try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcPath));         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destPath))) {        int content = 0;        while ((content = ()) != -1) {            (content);        }    } catch (IOException e) {        ();    }    long endTime = (); // 记录结束时间    ("使用缓冲字节流复制 PDF 文件总耗时 " + (endTime - startTime) + " 毫秒");}

结果对比

yaml复制代码使用字节流复制 PDF 文件总耗时 1052141 毫秒使用缓冲字节流复制 PDF 文件总耗时 6521 毫秒

可以看到，两者耗时差别绝大，相较于字节流，使用缓冲字节流节省约 161 倍的耗时。

测试对比 2（字节数组处理）

分别使用字节流+字节数组、字节缓冲流+字节数组的方式复制一个 207 MB 的 PDF 文件，查看耗时对比。

代码

1. 使用字节流 + 字节数组复制 PDF 文件

java复制代码@Testpublic void copyFileByByteArrStream() {    ("使用字节流+字节数组复制 PDF 文件测试开始");    long startTime = (); // 记录开始时间    // 文件大小 207 MB    String srcPath = "/Users/sunnywinter/Downloads/深入剖析";    String destPath = "/Users/sunnywinter/Downloads/深入剖析";    try (FileInputStream fis = new FileInputStream(srcPath);         FileOutputStream fos = new FileOutputStream(destPath)) {        int readLen = 0;        byte[] b = new byte[8 * 1024];        while ((readLen = (b)) != -1) {            (b, 0, readLen);        }    } catch (IOException e) {        ();    }    long endTime = (); // 记录结束时间    ("使用字节流 + 字节数组复制 PDF 文件总耗时 " + (endTime - startTime) + " 毫秒");}

2. 使用缓冲字节流 + 字节数组复制 PDF 文件

java复制代码@Testpublic void copyFileByByteArrBufferStream() {    ("使用缓冲字节流+字节数组复制 PDF 文件测试开始");    long startTime = (); // 记录开始时间    // 文件大小 207 MB    String srcPath = "/Users/sunnywinter/Downloads/深入剖析";    String destPath = "/Users/sunnywinter/Downloads/深入剖析";    try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcPath));         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destPath))) {        int readLen = 0;        byte[] b = new byte[8 * 1024];        while ((readLen = (b)) != -1) {            (b, 0, readLen);        }    } catch (IOException e) {        ();    }    long endTime = (); // 记录结束时间    ("使用缓冲字节流 + 字节数组复制 PDF 文件总耗时" + (endTime - startTime) + "毫秒");}

结果对比

复制代码使用字节流 + 字节数组复制 PDF 文件总耗时 478 毫秒使用缓冲字节流 + 字节数组复制 PDF 文件总耗时 391 毫秒

可以看到，两者差距不是特别大，但是 缓冲字节流仍具有优势 。

结论

在日常使用时，应当使用缓冲流，以获取更好的性能优势。

字符缓冲流也是同理，限于篇幅，不再提供测试案例，感兴趣的同学可以自行测试。

源码分析

BufferedInputStream

BufferedInputStream 内部维护了一个缓冲区，这个缓冲区是一个字节数组。下面是源码中的一部分内容：

java复制代码publicclass BufferedInputStream extends FilterInputStream {    // 缓冲区默认大小private static int DEFAULT_BUFFER_SIZE = 8192;    // 内部缓冲区字节数组    protected volatile byte buf[];    // 构造函数，使用默认的缓冲区大小    public BufferedInputStream(InputStream in) {        this(in, DEFAULT_BUFFER_SIZE);    }    // 构造函数，使用自定义的缓冲区大小    public BufferedInputStream(InputStream in, int size) {        super(in);        if (size <= 0) {            throw new IllegalArgumentException("Buffer size <= 0");        }        buf = new byte[size];    }}

BufferedOutputStream

下面是源码中的一部分内容：

java复制代码publicclass BufferedOutputStream extends FilterOutputStream {    // 内部缓冲区字节数组    protected byte buf[];    // 构造函数，默认缓冲区大小为 8192     public BufferedOutputStream(OutputStream out) {        this(out, 8192);    }    // 构造函数，使用自定义的缓冲区大小    public BufferedOutputStream(OutputStream out, int size) {        super(out);        if (size <= 0) {            throw new IllegalArgumentException("Buffer size <= 0");        }        buf = new byte[size];    }}

BufferedReader

和 BufferedInputStream 一样，在内部维护了一个缓冲区，不同的是，这里是字符缓冲区。下面是源码中的一部分内容：

java复制代码public class BufferedReader extends Reader {    // 内部缓冲区字符数组private char cb[];    // 默认缓冲区大小    private static int defaultCharBufferSize = 8192;    // 构造函数，使用自定义的缓冲区大小    public BufferedReader(Reader in, int sz) {        super(in);        if (sz <= 0)            throw new IllegalArgumentException("Buffer size <= 0");         = in;        cb = new char[sz];        nextChar = nChars = 0;    }    // 构造函数，使用默认缓冲区大小    public BufferedReader(Reader in) {        this(in, defaultCharBufferSize);    }}

BufferedWriter

下面是源码中的一部分内容：

java复制代码public class BufferedWriter extends Writer {// 内部缓冲区字符数组    private char cb[];    // 默认缓冲区大小    private static int defaultCharBufferSize = 8192;    // 构造函数，使用默认缓冲区大小    public BufferedWriter(Writer out) {        this(out, defaultCharBufferSize);    }    // 构造函数，使用自定义的缓冲区大小    public BufferedWriter(Writer out, int sz) {        super(out);        if (sz <= 0)            throw new IllegalArgumentException("Buffer size <= 0");         = out;        cb = new char[sz];        nChars = sz;        nextChar = 0;        lineSeparator = (            new (""));    }}

打印流

打印流只有输出流(内存 ->文件)，没有输入流。

PrintStream(字节打印流)

我们经常使用的 就是用于获取一个 PrintStream 对象， 方法实际调用的是 PrintStream 对象的 write 方法。

默认情况下，PrintStream 输出数据的位置是标准输出，即显示器。

类图关系如下：

源码

下面是 PrintStream 的部分源码：

java复制代码public class PrintStream extends FilterOutputStream    implements Appendable, Closeable{    // 调用的 write 方法    public void print(String s) {        if (s == null) {            s = "null";        }        write(s);    }        private void write(String s) {        try {            synchronized (this) {                ensureOpen();                (s);                ();                ();                if (autoFlush && (("
") >= 0))                    ();            }        }        catch (InterruptedIOException x) {            ().interrupt();        }        catch (IOException x) {            trouble = true;        }    }}

PrintWriter(字符打印流)

包装了 FileWriter ，提供了更方便的方法来完成输出。

类图关系如下

这里我就给出一个案例来说明字符打印流要如何使用。

需求：将 中内容打印到 文件中。

代码

java复制代码@Testpublic void testPrintWriter() {    try (BufferedReader br = new BufferedReader(new FileReader(""));         PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("")))) {        String line = null;        while ((line = ()) != null) { // 一次读取一行内容，为空时代表读取结束            (line); // 换行并打印到指定文件中        }    } catch (IOException e) {        ();    }}

运行结果

随机访问流

在本小结，主要介绍 支持随意跳转到文件任意位置读写 的 RandomAccessFile 类。

类关系如下：

构造函数

构造函数的源码如下：

java复制代码// String name: 指定名称的文件public RandomAccessFile(String name, String mode)    throws FileNotFoundException{    this(name != null ? new File(name) : null, mode);}// String file: 指定文件public RandomAccessFile(File file, String mode)        throws FileNotFoundException{    // 省略...}

我们重点介绍输入参数 mode(读写模式)。根据源码中的注释，读写模式共四种：

什么是「文件内容」？什么是「元数据」？

「文件内容」指的是文件中实际保存的数据，「元数据」则是用来描述文件属性比如文件的大小信息、创建和修改时间。

rwd 相较于 rws 来说，可以减少执行 IO 操作次数。

文件指针

RandomAccessFile 中有一个文件指针用于表示 下一个将要被写入或者读取的字节所处的位置 。

我们可以通过 seek(long pos) 设置文件指针的偏移量 (据文件开头 pos 个字节处)。源码如下：

java复制代码public void seek(long pos) throws IOException {    if (pos < 0) {        throw new IOException("Negative seek offset");    } else {        seek0(pos);    }}private native void seek0(long pos) throws IOException;

如果想要 获取文件指针当前位置 的话，可以使用 getFilePointer() 方法。源码如下：

java复制代码public native long getFilePointer() throws IOException;

常见方法

使用案例

java复制代码@Testpublic void testRandomAccessFile() {    try(RandomAccessFile raf = new RandomAccessFile(new File(""), "rw")) {        // readLine() 读取一行文本        ("起始文件内容：" + ());        (0); // 设置文件指针偏移量为 0，回到起始位置        // read() 读取一个字节        // getFilePointer 获取文件指针当前位置        ("读取前的偏移量：" + () + "，当前读取的字符：" + (char) () + "，读取后的偏移量：" + ());        (6); // 设置文件指针偏移量为 6        ("读取前的偏移量：" + () + "，当前读取的字符：" + (char) () + "，读取后的偏移量：" + ());        (new byte[]{"h", "i"});        ("写入后的偏移量：" + () + "，当前读取的字符：" + (char) () + "，读取后的偏移量：" + ());        (0); // 设置文件指针偏移量为 0，回到起始位置        ("当前文件的内容为：" + ());        (0); // 设置文件指针偏移量为 0，回到起始位置        (new byte[]{"A", "B", "C"}); // 覆盖数据        (0);        ("覆盖后的文件内容为：" + ());    } catch (IOException e) {        ();    }}

运行结果

css复制代码起始文件内容：abcdefg读取前的偏移量：0，当前读取的字符：a，读取后的偏移量：1读取前的偏移量：6，当前读取的字符：g，读取后的偏移量：7写入后的偏移量：9，当前读取的字符：，读取后的偏移量：9当前文件的内容为：abcdefghi覆盖后的文件内容为：ABCdefghi

应用场景

RandomAccessFile 比较常见的一个应用就是实现大文件的 断点续传 。

何谓断点续传？简单来说就是上传文件中途暂停或失败（比如遇到网络问题）之后，不需要重新上传，只需要上传那些未成功上传的文件分片即可。分片（先将文件切分成多个文件分片）上传是断点续传的基础。

该部分内容我们会在后续实战部分中，手写一个断点续传下载器进行详细讲解。

综合应用案例

案例 1：格式化读取写入文本

需求说明

1. 给定一个 Employee 类。

java复制代码public class Employee {    private String name; // 姓名    private double salary; // 薪水    private LocalDate hireDay; // 雇佣日期    public Employee(String n, double s, int year, int month, int day)    {        name = n;        salary = s;        hireDay = (year, month, day);    }    public String getName()    {        return name;    }    public double getSalary()    {        return salary;    }    public LocalDate getHireDay()    {        return hireDay;    }    // 加薪    public void raiseSalary(double byPercent)    {        double raise = salary * byPercent / 100;        salary += raise;    }    @Override    public String toString()    {        return getClass().getName()                + "[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";    }}

2. 我们需要按照指定格式写入到 文件中。

第一行数字是写入的记录数量。

指定格式：姓名|薪水|入职时间

复制代码3Carl Cracker||1987-12-15Harry Hacker||1989-10-01Tony Tester||1990-03-15

3. 从 文件中读取数据打印到控制台中。

代码

java复制代码public class Main {   @Test    public void test() throws IOException {        Employee[] staff = new Employee[3];        staff[0] = new Employee("Carl Cracker", 75000, 1987, 12, 15);        staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);        staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15);        // 按照指定格式写入到 `` 文件中。        try (PrintWriter out = new PrintWriter("", (_8))) {            ();            for (Employee e : staff) {                (() + "|" + () + "|" + ());            }        }        // 从 `` 文件中读取数据打印到控制台中。        try (Scanner in = new Scanner(new FileInputStream(""), (_8))) {            int n = ();            ();            Employee[] employees = new Employee[n];            for (int i = 0; i < n; i++) {                employees[i] = readEmployee(in);            }            for (Employee e : employees) {                (e);            }        }    }    public Employee readEmployee(Scanner in) {        String line = ();        // split 方法的参数是一个描述分隔符的正则表达式。        // 由于 "|" 在正则表达式中有特殊含义，所以需要 "\" 来转义，而 "\" 还需要一个 "\" 来转义。        // 所以，表达式为 "\|"。        String[] tokens = ("\|");        String name = tokens[0];        double salary = (tokens[1]);        LocalDate hireDate = (tokens[2]);        int year = ();        int month = ();        int day = ();        return new Employee(name, salary, year, month, day);    } }

运行结果

css复制代码[name=Carl Cracker,salary=,hireDay=1987-12-15][name=Harry Hacker,salary=,hireDay=1989-10-01][name=Tony Tester,salary=,hireDay=1990-03-15]

总结

在这一讲中，我们讲解了如何判断输入、输出流，字节流和字符流的区别和使用场景，缓冲流和普通流的对比实验，什么是打印流，最后介绍了随机访问流。

在下一讲中，我们去看看设计模式是如何在 Java IO 中应用的。

参考资料

更新日志

作者：柿子先生 链接：/post/7233337405377593405

标签：