• 1.2w+字！Java IO 基础知识总结

    IO 流简介

    IO 即 Input/Output ，输入和输出。数据输入到计算机内存的过程即输入，反之输出到外部存储(比如数据库，文件，远程主机)的过程即输出。数据传输过程类似于水流，因此称为 IO 流。IO 流在 Java 中分为输入流和输出流，而根据数据的处理方式又分为字节流和字符流。

    Java IO 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。

    • InputStream / Reader : 所有的输入流的基类，前者是字节输入流，后者是字符输入流。

    • OutputStream / Writer : 所有输出流的基类，前者是字节输出流，后者是字符输出流。

    字节流

    InputStream(字节输入流)

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

    InputStream 常用方法 ：

    • read() ：返回输入流中下一个字节的数据。返回的值介于 0 到 255 之间。如果未读取任何字节，则代码返回 -1 ，表示文件结束。

      1. read(byte b[ ])
      2. b
      3. b
      4. -1
      5. b.length
      6. read(b, 0, b.length)
       
      1. read(byte b[], int off, int len)
      2. read(byte b[ ])
      3. off
      4. len

    • skip(long n) ：忽略输入流中的 n 个字节 ,返回实际忽略的字节数。

    • available() ：返回输入流中可以读取的字节数。

    • close() ：关闭输入流释放相关的系统资源。

    从 Java 9 开始， InputStream 新增加了多个实用的方法：

    • readAllBytes() ：读取输入流中的所有字节，返回字节数组。

    • readNBytes(byte[] b, int off, int len) ：阻塞直到读取 len 个字节。

    • transferTo(OutputStream out) ：将所有字节从一个输入流传递到一个输出流。

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

    FileInputStream 代码示例：

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         try (InputStream fis = 
    10.         
    11.         new FileInputStream(
    12.         
    13.         "input.txt")) {
    14.        
    15.        
    16.       
    17.       
    18.       
    19.       
    20.        
    21.        
    22.         
    23.             System.
    24.         
    25.         out.println(
    26.         
    27.         "Number of remaining bytes:"
    28.        
    29.        
    30.       
    31.       
    32.       
    33.       
    34.        
    35.        
    36.         
    37.                     + fis.available());
    38.        
    39.        
    40.       
    41.       
    42.       
    43.       
    44.        
    45.            
    46.         
    47.         int content;
    48.        
    49.        
    50.       
    51.       
    52.       
    53.       
    54.        
    55.            
    56.         
    57.         long skip = fis.skip(
    58.         
    59.         2);
    60.        
    61.        
    62.       
    63.       
    64.       
    65.       
    66.        
    67.        
    68.         
    69.             System.
    70.         
    71.         out.println(
    72.         
    73.         "The actual number of bytes skipped:" + skip);
    74.        
    75.        
    76.       
    77.       
    78.       
    79.       
    80.        
    81.        
    82.         
    83.             System.
    84.         
    85.         out.print(
    86.         
    87.         "The content read from file:");
    88.        
    89.        
    90.       
    91.       
    92.       
    93.       
    94.        
    95.            
    96.         
    97.         while ((content = fis.read()) != 
    98.         
    99.         -1) {
    100.        
    101.        
    102.       
    103.       
    104.       
    105.       
    106.        
    107.        
    108.         
    109.                 System.
    110.         
    111.         out.print((
    112.         
    113.         char) content);
    114.        
    115.        
    116.       
    117.       
    118.       
    119.       
    120.        
    121.        
    122.         
    123.             }
    124.        
    125.        
    126.       
    127.       
    128.       
    129.       
    130.        
    131.        
    132.         
    133.         } 
    134.         
    135.         catch (IOException e) {
    136.        
    137.        
    138.       
    139.       
    140.       
    141.       
    142.        
    143.        
    144.         
    145.             e.printStackTrace();
    146.        
    147.        
    148.       
    149.       
    150.       
    151.       
    152.        
    153.        
    154.         
    155.         }
    156.        
    157.        
    158.

    input.txt 文件内容：

    输出：

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         Number 
    10.         
    11.         of remaining 
    12.         
    13.         bytes:
    14.         
    15.         11
    16.        
    17.        
    18.       
    19.       
    20.       
    21.       
    22.        
    23.        
    24.         
    25.         The actual 
    26.         
    27.         number 
    28.         
    29.         of bytes 
    30.         
    31.         skipped:
    32.         
    33.         2
    34.        
    35.        
    36.       
    37.       
    38.       
    39.       
    40.        
    41.        
    42.         
    43.         The content read 
    44.         
    45.         from 
    46.         
    47.         file:
    48.         
    49.         JavaGuide
    50.        
    51.        
    52.

    不过，一般我们是不会直接单独使用 FileInputStream ，通常会配合 BufferedInputStream (字节缓冲输入流，后文会讲到)来使用。

    像下面这段代码在我们的项目中就比较常见，我们通过 readAllBytes() 读取输入流所有字节并将其直接赋值给一个 String 对象。

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         // 新建一个 BufferedInputStream 对象
    10.        
    11.        
    12.       
    13.       
    14.       
    15.       
    16.        
    17.        
    18.         
    19.         BufferedInputStream bufferedInputStream = 
    20.         
    21.         new 
    22.         
    23.         BufferedInputStream(
    24.         
    25.         new 
    26.         
    27.         FileInputStream(
    28.         
    29.         "input.txt"));
    30.        
    31.        
    32.       
    33.       
    34.       
    35.       
    36.        
    37.        
    38.         
    39.         // 读取文件的内容并复制到 String 对象中
    40.        
    41.        
    42.       
    43.       
    44.       
    45.       
    46.        
    47.        
    48.         
    49.         String result = 
    50.         
    51.         new 
    52.         
    53.         String(bufferedInputStream.
    54.         
    55.         readAllBytes());
    56.        
    57.        
    58.       
    59.       
    60.       
    61.       
    62.        
    63.        
    64.         
    65.         System.
    66.         
    67.         out.
    68.         
    69.         println(result);
    70.        
    71.        
    72.

    DataInputStream 用于读取指定类型数据，不能单独使用，必须结合 FileInputStream 。

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         FileInputStream 
    10.         
    11.         fileInputStream 
    12.         
    13.         = 
    14.         
    15.         new 
    16.         
    17.         FileInputStream(
    18.         
    19.         "input.txt");
    20.        
    21.        
    22.       
    23.       
    24.       
    25.       
    26.        
    27.        
    28.         
    29.         //必须将fileInputStream作为构造参数才能使用
    30.        
    31.        
    32.       
    33.       
    34.       
    35.       
    36.        
    37.        
    38.         
    39.         DataInputStream 
    40.         
    41.         dataInputStream 
    42.         
    43.         = 
    44.         
    45.         new 
    46.         
    47.         DataInputStream(fileInputStream);
    48.        
    49.        
    50.       
    51.       
    52.       
    53.       
    54.        
    55.        
    56.         
    57.         //可以读取任意具体的类型数据
    58.        
    59.        
    60.       
    61.       
    62.       
    63.       
    64.        
    65.        
    66.         
    67.         dataInputStream.readBoolean();
    68.        
    69.        
    70.       
    71.       
    72.       
    73.       
    74.        
    75.        
    76.         
    77.         dataInputStream.readInt();
    78.        
    79.        
    80.       
    81.       
    82.       
    83.       
    84.        
    85.        
    86.         
    87.         dataInputStream.readUTF();
    88.        
    89.        
    90.

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

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         ObjectInputStream input = 
    10.         
    11.         new ObjectInputStream(
    12.         
    13.         new FileInputStream(
    14.         
    15.         "object.data"));
    16.        
    17.        
    18.       
    19.       
    20.       
    21.       
    22.        
    23.        
    24.         
    25.         MyClass 
    26.         
    27.         object = (
    28.         
    29.         MyClass) input.readObject();
    30.        
    31.        
    32.       
    33.       
    34.       
    35.       
    36.        
    37.        
    38.         
    39.         input.close();
    40.        
    41.        
    42.

    另外，用于序列化和反序列化的类必须实现 Serializable 接口，对象中如果有属性不想被序列化，使用 transient 修饰。

    OutputStream(字节输出流)

    OutputStream 用于将数据(字节信息)写入到目的地(通常是文件)， java.io.OutputStream 抽象类是所有字节输出流的父类。

    OutputStream 常用方法 ：

    • write(int b) ：将特定字节写入输出流。

      1. write(byte b[ ])
      2. b
      3. write(b, 0, b.length)
       
      1. write(byte[] b, int off, int len)
      2. write(byte b[ ])
      3. off
      4. len

    • flush() ：刷新此输出流并强制写出所有缓冲的输出字节。

    • close() ：关闭输出流释放相关的系统资源。

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

    FileOutputStream 代码示例：

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         try (FileOutputStream output = 
    10.         
    11.         new 
    12.         
    13.         FileOutputStream(
    14.         
    15.         "output.txt")) {
    16.        
    17.        
    18.       
    19.       
    20.       
    21.       
    22.        
    23.        
    24.         
    25.             byte[] 
    26.         
    27.         array = 
    28.         
    29.         "JavaGuide".
    30.         
    31.         getBytes();
    32.        
    33.        
    34.       
    35.       
    36.       
    37.       
    38.        
    39.        
    40.         
    41.             output.
    42.         
    43.         write(
    44.         
    45.         array);
    46.        
    47.        
    48.       
    49.       
    50.       
    51.       
    52.        
    53.        
    54.         
    55.         } 
    56.         
    57.         catch (IOException e) {
    58.        
    59.        
    60.       
    61.       
    62.       
    63.       
    64.        
    65.        
    66.         
    67.             e.
    68.         
    69.         printStackTrace();
    70.        
    71.        
    72.       
    73.       
    74.       
    75.       
    76.        
    77.        
    78.         
    79.         }
    80.        
    81.        
    82.

    运行结果：

    类似于 FileInputStream ， FileOutputStream 通常也会配合 BufferedOutputStream (字节缓冲输出流，后文会讲到)来使用。

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         FileOutputStream 
    10.         
    11.         fileOutputStream 
    12.         
    13.         = 
    14.         
    15.         new 
    16.         
    17.         FileOutputStream(
    18.         
    19.         "output.txt");
    20.        
    21.        
    22.       
    23.       
    24.       
    25.       
    26.        
    27.        
    28.         
    29.         BufferedOutputStream 
    30.         
    31.         bos 
    32.         
    33.         = 
    34.         
    35.         new 
    36.         
    37.         BufferedOutputStream(fileOutputStream)
    38.        
    39.        
    40.

    DataOutputStream 用于写入指定类型数据，不能单独使用，必须结合 FileOutputStream

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         // 输出流
    10.        
    11.        
    12.       
    13.       
    14.       
    15.       
    16.        
    17.        
    18.         
    19.         FileOutputStream 
    20.         
    21.         fileOutputStream 
    22.         
    23.         = 
    24.         
    25.         new 
    26.         
    27.         FileOutputStream(
    28.         
    29.         "out.txt");
    30.        
    31.        
    32.       
    33.       
    34.       
    35.       
    36.        
    37.        
    38.         
    39.         DataOutputStream 
    40.         
    41.         dataOutputStream 
    42.         
    43.         = 
    44.         
    45.         new 
    46.         
    47.         DataOutputStream(fileOutputStream);
    48.        
    49.        
    50.       
    51.       
    52.       
    53.       
    54.        
    55.        
    56.         
    57.         // 输出任意数据类型
    58.        
    59.        
    60.       
    61.       
    62.       
    63.       
    64.        
    65.        
    66.         
    67.         dataOutputStream.writeBoolean(
    68.         
    69.         true);
    70.        
    71.        
    72.       
    73.       
    74.       
    75.       
    76.        
    77.        
    78.         
    79.         dataOutputStream.writeByte(
    80.         
    81.         1);
    82.        
    83.        
    84.

    ObjectOutputStream 用于从输入流中读取 Java 对象( ObjectInputStream ,反序列化)或者将对象写入到输出流( ObjectOutputStream ，序列化)。

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         ObjectOutputStream 
    10.         
    11.         output 
    12.         
    13.         = 
    14.         
    15.         new 
    16.         
    17.         ObjectOutputStream(
    18.         
    19.         new 
    20.         
    21.         FileOutputStream(
    22.         
    23.         "file.txt")
    24.        
    25.        
    26.       
    27.       
    28.       
    29.       
    30.        
    31.        
    32.         
    33.         Person 
    34.         
    35.         person 
    36.         
    37.         = 
    38.         
    39.         new 
    40.         
    41.         Person(
    42.         
    43.         "Guide哥", 
    44.         
    45.         "JavaGuide作者");
    46.        
    47.        
    48.       
    49.       
    50.       
    51.       
    52.        
    53.        
    54.         
    55.         output.writeObject(person);
    56.        
    57.        
    58.

    字符流

    不管是文件读写还是网络发送接收，信息的最小存储单元都是字节。 那为什么 I/O 流操作要分为字节流操作和字符流操作呢？

    个人认为主要有两点原因：

    • 字符流是由 Java 虚拟机将字节转换得到的，这个过程还算是比较耗时。

    • 如果我们不知道编码类型就很容易出现乱码问题。

    乱码问题这个很容易就可以复现，我们只需要将上面提到的 FileInputStream 代码示例中的 input.txt 文件内容改为中文即可，原代码不需要改动。

    输出：

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         Number 
    10.         
    11.         of remaining 
    12.         
    13.         bytes:
    14.         
    15.         9
    16.        
    17.        
    18.       
    19.       
    20.       
    21.       
    22.        
    23.        
    24.         
    25.         The actual 
    26.         
    27.         number 
    28.         
    29.         of bytes 
    30.         
    31.         skipped:
    32.         
    33.         2
    34.        
    35.        
    36.       
    37.       
    38.       
    39.       
    40.        
    41.        
    42.         
    43.         The content read 
    44.         
    45.         from 
    46.         
    47.         file:§å®¶å¥½
    48.        
    49.        
    50.

    可以很明显地看到读取出来的内容已经变成了乱码。

    因此，I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。

    字符流默认采用的是 Unicode 编码，我们可以通过构造方法自定义编码。顺便分享一下之前遇到的笔试题：常用字符编码所占字节数？ utf8 :英文占 1 字节，中文占 3 字节， unicode ：任何字符都占 2 个字节， gbk ：英文占 1 字节，中文占 2 字节。

    Reader(字符输入流)

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

    Reader 用于读取文本， InputStream 用于读取原始字节。

    Reader 常用方法 ：

    • read() : 从输入流读取一个字符。

      1. read(char[] cbuf)
      2. cbuf
      3. read(cbuf, 0, cbuf.length)
       
      1. read(char[] cbuf, int off, int len)
      2. read(char[] cbuf)
      3. off
      4. len

    • skip(long n) ：忽略输入流中的 n 个字符 ,返回实际忽略的字符数。

    • close() : 关闭输入流并释放相关的系统资源。

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

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         // 字节流转换为字符流的桥梁
    10.        
    11.        
    12.       
    13.       
    14.       
    15.       
    16.        
    17.        
    18.         
    19.         public 
    20.         
    21.         class InputStreamReader extends Reader {
    22.        
    23.        
    24.       
    25.       
    26.       
    27.       
    28.        
    29.        
    30.         
    31.         }
    32.        
    33.        
    34.       
    35.       
    36.       
    37.       
    38.        
    39.        
    40.         
    41.         // 用于读取字符文件
    42.        
    43.        
    44.       
    45.       
    46.       
    47.       
    48.        
    49.        
    50.         
    51.         public 
    52.         
    53.         class FileReader extends InputStreamReader {
    54.        
    55.        
    56.       
    57.       
    58.       
    59.       
    60.        
    61.        
    62.         
    63.         }
    64.        
    65.        
    66.

    FileReader 代码示例：

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         try (
    10.         
    11.         FileReader fileReader = new FileReader(
    12.         
    13.         "input.txt")
    14.         
    15.         ;) {
    16.        
    17.        
    18.       
    19.       
    20.       
    21.       
    22.        
    23.        
    24.         
    25.             int content
    26.         
    27.         ;
    28.        
    29.        
    30.       
    31.       
    32.       
    33.       
    34.        
    35.        
    36.         
    37.             long skip = fileReader.skip(
    38.         
    39.         3)
    40.         
    41.         ;
    42.        
    43.        
    44.       
    45.       
    46.       
    47.       
    48.        
    49.        
    50.         
    51.             System.out.println(
    52.         
    53.         "The actual number of bytes skipped:" + skip)
    54.         
    55.         ;
    56.        
    57.        
    58.       
    59.       
    60.       
    61.       
    62.        
    63.        
    64.         
    65.             System.out.print(
    66.         
    67.         "The content read from file:")
    68.         
    69.         ;
    70.        
    71.        
    72.       
    73.       
    74.       
    75.       
    76.        
    77.        
    78.         
    79.             while ((
    80.         
    81.         content = fileReader.read()) != 
    82.         
    83.         -1) {
    84.        
    85.        
    86.       
    87.       
    88.       
    89.       
    90.        
    91.        
    92.         
    93.                 System.out.print((
    94.         
    95.         char) content)
    96.         
    97.         ;
    98.        
    99.        
    100.       
    101.       
    102.       
    103.       
    104.        
    105.        
    106.         
    107.             }
    108.        
    109.        
    110.       
    111.       
    112.       
    113.       
    114.        
    115.        
    116.         
    117.         } catch (
    118.         
    119.         IOException e) {
    120.        
    121.        
    122.       
    123.       
    124.       
    125.       
    126.        
    127.        
    128.         
    129.             e.printStackTrace()
    130.         
    131.         ;
    132.        
    133.        
    134.       
    135.       
    136.       
    137.       
    138.        
    139.        
    140.         
    141.         }
    142.        
    143.        
    144.

    input.txt 文件内容：

    输出：

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         The actual number 
    10.         
    11.         of bytes skipped:
    12.         
    13.         3
    14.        
    15.        
    16.       
    17.       
    18.       
    19.       
    20.        
    21.        
    22.         
    23.         The content 
    24.         
    25.         read from 
    26.         
    27.         file:我是Guide。
    28.        
    29.        
    30.

    Writer(字符输出流)

    Writer 用于将数据(字符信息)写入到目的地(通常是文件)， java.io.Writer 抽象类是所有字节输出流的父类。

    Writer 常用方法 ：

    • write(int c) : 写入单个字符。

      1. write(char[] cbuf)
      2. cbuf
      3. write(cbuf, 0, cbuf.length)
       
      1. write(char[] cbuf, int off, int len)
      2. write(char[] cbuf)
      3. off
      4. len

    • write(String str) ：写入字符串，等价于 write(str, 0, str.length()) 。

      1. write(String str, int off, int len)
      2. write(String str)
      3. off
      4. len
       
      1. append(CharSequence csq)
      2. Writer
      3. Writer
       
      1. append(char c)
      2. Writer
      3. Writer

    • flush() ：刷新此输出流并强制写出所有缓冲的输出字符。

    • close() :关闭输出流释放相关的系统资源。

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

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         // 字符流转换为字节流的桥梁
    10.        
    11.        
    12.       
    13.       
    14.       
    15.       
    16.        
    17.        
    18.         
    19.         public 
    20.         
    21.         class InputStreamReader extends Reader {
    22.        
    23.        
    24.       
    25.       
    26.       
    27.       
    28.        
    29.        
    30.         
    31.         }
    32.        
    33.        
    34.       
    35.       
    36.       
    37.       
    38.        
    39.        
    40.         
    41.         // 用于写入字符到文件
    42.        
    43.        
    44.       
    45.       
    46.       
    47.       
    48.        
    49.        
    50.         
    51.         public 
    52.         
    53.         class FileWriter extends OutputStreamWriter {
    54.        
    55.        
    56.       
    57.       
    58.       
    59.       
    60.        
    61.        
    62.         
    63.         }
    64.        
    65.        
    66.

    FileWriter 代码示例：

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         try (
    10.         
    11.         Writer 
    12.         
    13.         output 
    14.         
    15.         = 
    16.         
    17.         new 
    18.         
    19.         FileWriter(
    20.         
    21.         "output.txt")) {
    22.        
    23.        
    24.       
    25.       
    26.       
    27.       
    28.        
    29.        
    30.         
    31.             output.write(
    32.         
    33.         "你好，我是Guide。");
    34.        
    35.        
    36.       
    37.       
    38.       
    39.       
    40.        
    41.        
    42.         
    43.         } 
    44.         
    45.         catch (IOException e) {
    46.        
    47.        
    48.       
    49.       
    50.       
    51.       
    52.        
    53.        
    54.         
    55.             e.printStackTrace();
    56.        
    57.        
    58.       
    59.       
    60.       
    61.       
    62.        
    63.        
    64.         
    65.         }
    66.        
    67.        
    68.

    输出结果：

    字节缓冲流

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

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

    举个例子，我们可以通过 BufferedInputStream (字节缓冲输入流)来增强 FileInputStream 的功能。

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         // 新建一个 BufferedInputStream 对象
    10.        
    11.        
    12.       
    13.       
    14.       
    15.       
    16.        
    17.        
    18.         
    19.         BufferedInputStream 
    20.         
    21.         bufferedInputStream 
    22.         
    23.         = 
    24.         
    25.         new 
    26.         
    27.         BufferedInputStream(
    28.         
    29.         new 
    30.         
    31.         FileInputStream(
    32.         
    33.         "input.txt"));
    34.        
    35.        
    36.

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

    我使用 write(int b) 和 read() 方法，分别通过字节流和字节缓冲流复制一个 524.9 mb 的 PDF 文件耗时对比如下：

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         使用缓冲流复制PDF文件总耗时:15428 毫秒
    10.        
    11.        
    12.       
    13.       
    15.       
    16.       
    17.        
    18.        
    19.         
    20.         使用普通字节流复制PDF文件总耗时:2555062 毫秒
    21.        
    22.        
    23.       
    24.

    两者耗时差别非常大，缓冲流耗费的时间是字节流的 1/165。

    测试代码如下:

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         @Test
    10.        
    11.        
    12.       
    13.       
    14.       
    15.       
    16.        
    17.        
    18.         
    19.         void 
    20.         
    21.         copy_pdf_to_another_pdf_buffer_stream
    22.         
    23.         () {
    24.        
    25.        
    26.       
    27.       
    28.       
    29.       
    30.        
    31.            
    32.         
    33.         // 记录开始时间
    34.        
    35.        
    36.       
    37.       
    38.       
    39.       
    40.        
    41.            
    42.         
    43.         long 
    44.         
    45.         start 
    46.         
    47.         = System.currentTimeMillis();
    48.        
    49.        
    50.       
    51.       
    52.       
    53.       
    54.        
    55.            
    56.         
    57.         try (
    58.         
    59.         BufferedInputStream 
    60.         
    61.         bis 
    62.         
    63.         = 
    64.         
    65.         new 
    66.         
    67.         BufferedInputStream(
    68.         
    69.         new 
    70.         
    71.         FileInputStream(
    72.         
    73.         "深入理解计算机操作系统.pdf"));
    74.        
    75.        
    76.       
    77.       
    78.       
    79.       
    80.        
    81.                 
    82.         
    83.         BufferedOutputStream 
    84.         
    85.         bos 
    86.         
    87.         = 
    88.         
    89.         new 
    90.         
    91.         BufferedOutputStream(
    92.         
    93.         new 
    94.         
    95.         FileOutputStream(
    96.         
    97.         "深入理解计算机操作系统-副本.pdf"))) {
    98.        
    99.        
    100.       
    101.       
    102.       
    103.       
    104.        
    105.                
    106.         
    107.         int content;
    108.        
    109.        
    110.       
    111.       
    112.       
    113.       
    114.        
    115.                
    116.         
    117.         while ((content = bis.read()) != -
    118.         
    119.         1) {
    120.        
    121.        
    122.       
    123.       
    124.       
    125.       
    126.        
    127.        
    128.         
    129.                     bos.write(content);
    130.        
    131.        
    132.       
    133.       
    134.       
    135.       
    136.        
    137.        
    138.         
    139.                 }
    140.        
    141.        
    142.       
    143.       
    144.       
    145.       
    146.        
    147.        
    148.         
    149.             } 
    150.         
    151.         catch (IOException e) {
    152.        
    153.        
    154.       
    155.       
    156.       
    157.       
    158.        
    159.        
    160.         
    161.                 e.printStackTrace();
    162.        
    163.        
    164.       
    165.       
    166.       
    167.       
    168.        
    169.        
    170.         
    171.             }
    172.        
    173.        
    174.       
    175.       
    176.       
    177.       
    178.        
    179.            
    180.         
    181.         // 记录结束时间
    182.        
    183.        
    184.       
    185.       
    186.       
    187.       
    188.        
    189.            
    190.         
    191.         long 
    192.         
    193.         end 
    194.         
    195.         = System.currentTimeMillis();
    196.        
    197.        
    198.       
    199.       
    200.       
    201.       
    202.        
    203.        
    204.         
    205.             System.out.println(
    206.         
    207.         "使用缓冲流复制PDF文件总耗时:" + (end - start) + 
    208.         
    209.         " 毫秒");
    210.        
    211.        
    212.       
    213.       
    214.       
    215.       
    216.        
    217.        
    218.         
    219.         }
    220.        
    221.        
    222.       
    223.       
    224.       
    225.       
    226.        
    227.        
    228.         
    229.         @Test
    230.        
    231.        
    232.       
    233.       
    234.       
    235.       
    236.        
    237.        
    238.         
    239.         void 
    240.         
    241.         copy_pdf_to_another_pdf_stream
    242.         
    243.         () {
    244.        
    245.        
    246.       
    247.       
    248.       
    249.       
    250.        
    251.            
    252.         
    253.         // 记录开始时间
    254.        
    255.        
    256.       
    257.       
    258.       
    259.       
    260.        
    261.            
    262.         
    263.         long 
    264.         
    265.         start 
    266.         
    267.         = System.currentTimeMillis();
    268.        
    269.        
    270.       
    271.       
    272.       
    273.       
    274.        
    275.            
    276.         
    277.         try (
    278.         
    279.         FileInputStream 
    280.         
    281.         fis 
    282.         
    283.         = 
    284.         
    285.         new 
    286.         
    287.         FileInputStream(
    288.         
    289.         "深入理解计算机操作系统.pdf");
    290.        
    291.        
    292.       
    293.       
    294.       
    295.       
    296.        
    297.                 
    298.         
    299.         FileOutputStream 
    300.         
    301.         fos 
    302.         
    303.         = 
    304.         
    305.         new 
    306.         
    307.         FileOutputStream(
    308.         
    309.         "深入理解计算机操作系统-副本.pdf")) {
    310.        
    311.        
    312.       
    313.       
    314.       
    315.       
    316.        
    317.                
    318.         
    319.         int content;
    320.        
    321.        
    322.       
    323.       
    324.       
    325.       
    326.        
    327.                
    328.         
    329.         while ((content = fis.read()) != -
    330.         
    331.         1) {
    332.        
    333.        
    334.       
    335.       
    336.       
    337.       
    338.        
    339.        
    340.         
    341.                     fos.write(content);
    342.        
    343.        
    344.       
    345.       
    346.       
    347.       
    348.        
    349.        
    350.         
    351.                 }
    352.        
    353.        
    354.       
    355.       
    356.       
    357.       
    358.        
    359.        
    360.         
    361.             } 
    362.         
    363.         catch (IOException e) {
    364.        
    365.        
    366.       
    367.       
    368.       
    369.       
    370.        
    371.        
    372.         
    373.                 e.printStackTrace();
    374.        
    375.        
    376.       
    377.       
    378.       
    379.       
    380.        
    381.        
    382.         
    383.             }
    384.        
    385.        
    386.       
    387.       
    388.       
    389.       
    390.        
    391.            
    392.         
    393.         // 记录结束时间
    394.        
    395.        
    396.       
    397.       
    398.       
    399.       
    400.        
    401.            
    402.         
    403.         long 
    404.         
    405.         end 
    406.         
    407.         = System.currentTimeMillis();
    408.        
    409.        
    410.       
    411.       
    412.       
    413.       
    414.        
    415.        
    416.         
    417.             System.out.println(
    418.         
    419.         "使用普通流复制PDF文件总耗时:" + (end - start) + 
    420.         
    421.         " 毫秒");
    422.        
    423.        
    424.       
    425.       
    426.       
    427.       
    428.        
    429.        
    430.         
    431.         }
    432.        
    433.        
    434.

    如果是调用 read(byte b[]) 和 write(byte b[], int off, int len) 这两个写入一个字节数组的方法的话，只要字节数组的大小合适，两者的性能差距其实不大，基本可以忽略。

    这次我们使用 read(byte b[]) 和 write(byte b[], int off, int len) 方法，分别通过字节流和字节缓冲流复制一个 524.9 mb 的 PDF 文件耗时对比如下：

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         使用缓冲流复制PDF文件总耗时:695 毫秒
    10.        
    11.        
    12.       
    13.       
    15.       
    16.       
    17.        
    18.        
    19.         
    20.         使用普通字节流复制PDF文件总耗时:989 毫秒
    21.        
    22.        
    23.       
    24.

    两者耗时差别不是很大，缓冲流的性能要略微好一点点。

    测试代码如下：

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         @Test
    10.        
    11.        
    12.       
    13.       
    14.       
    15.       
    16.        
    17.        
    18.         
    19.         void 
    20.         
    21.         copy_pdf_to_another_pdf_with_byte_array_buffer_stream
    22.         
    23.         () {
    24.        
    25.        
    26.       
    27.       
    28.       
    29.       
    30.        
    31.            
    32.         
    33.         // 记录开始时间
    34.        
    35.        
    36.       
    37.       
    38.       
    39.       
    40.        
    41.            
    42.         
    43.         long 
    44.         
    45.         start 
    46.         
    47.         = System.currentTimeMillis();
    48.        
    49.        
    50.       
    51.       
    52.       
    53.       
    54.        
    55.            
    56.         
    57.         try (
    58.         
    59.         BufferedInputStream 
    60.         
    61.         bis 
    62.         
    63.         = 
    64.         
    65.         new 
    66.         
    67.         BufferedInputStream(
    68.         
    69.         new 
    70.         
    71.         FileInputStream(
    72.         
    73.         "深入理解计算机操作系统.pdf"));
    74.        
    75.        
    76.       
    77.       
    78.       
    79.       
    80.        
    81.                 
    82.         
    83.         BufferedOutputStream 
    84.         
    85.         bos 
    86.         
    87.         = 
    88.         
    89.         new 
    90.         
    91.         BufferedOutputStream(
    92.         
    93.         new 
    94.         
    95.         FileOutputStream(
    96.         
    97.         "深入理解计算机操作系统-副本.pdf"))) {
    98.        
    99.        
    100.       
    101.       
    102.       
    103.       
    104.        
    105.                
    106.         
    107.         int len;
    108.        
    109.        
    110.       
    111.       
    112.       
    113.       
    114.        
    115.                
    116.         
    117.         byte[] bytes = 
    118.         
    119.         new 
    120.         
    121.         byte[
    122.         
    123.         4 * 
    124.         
    125.         1024];
    126.        
    127.        
    128.       
    129.       
    130.       
    131.       
    132.        
    133.                
    134.         
    135.         while ((len = bis.read(bytes)) != -
    136.         
    137.         1) {
    138.        
    139.        
    140.       
    141.       
    142.       
    143.       
    144.        
    145.        
    146.         
    147.                     bos.write(bytes, 
    148.         
    149.         0, len);
    150.        
    151.        
    152.       
    153.       
    154.       
    155.       
    156.        
    157.        
    158.         
    159.                 }
    160.        
    161.        
    162.       
    163.       
    164.       
    165.       
    166.        
    167.        
    168.         
    169.             } 
    170.         
    171.         catch (IOException e) {
    172.        
    173.        
    174.       
    175.       
    176.       
    177.       
    178.        
    179.        
    180.         
    181.                 e.printStackTrace();
    182.        
    183.        
    184.       
    185.       
    186.       
    187.       
    188.        
    189.        
    190.         
    191.             }
    192.        
    193.        
    194.       
    195.       
    196.       
    197.       
    198.        
    199.            
    200.         
    201.         // 记录结束时间
    202.        
    203.        
    204.       
    205.       
    206.       
    207.       
    208.        
    209.            
    210.         
    211.         long 
    212.         
    213.         end 
    214.         
    215.         = System.currentTimeMillis();
    216.        
    217.        
    218.       
    219.       
    220.       
    221.       
    222.        
    223.        
    224.         
    225.             System.out.println(
    226.         
    227.         "使用缓冲流复制PDF文件总耗时:" + (end - start) + 
    228.         
    229.         " 毫秒");
    230.        
    231.        
    232.       
    233.       
    234.       
    235.       
    236.        
    237.        
    238.         
    239.         }
    240.        
    241.        
    242.       
    243.       
    244.       
    245.       
    246.        
    247.        
    248.         
    249.         @Test
    250.        
    251.        
    252.       
    253.       
    254.       
    255.       
    256.        
    257.        
    258.         
    259.         void 
    260.         
    261.         copy_pdf_to_another_pdf_with_byte_array_stream
    262.         
    263.         () {
    264.        
    265.        
    266.       
    267.       
    268.       
    269.       
    270.        
    271.            
    272.         
    273.         // 记录开始时间
    274.        
    275.        
    276.       
    277.       
    278.       
    279.       
    280.        
    281.            
    282.         
    283.         long 
    284.         
    285.         start 
    286.         
    287.         = System.currentTimeMillis();
    288.        
    289.        
    290.       
    291.       
    292.       
    293.       
    294.        
    295.            
    296.         
    297.         try (
    298.         
    299.         FileInputStream 
    300.         
    301.         fis 
    302.         
    303.         = 
    304.         
    305.         new 
    306.         
    307.         FileInputStream(
    308.         
    309.         "深入理解计算机操作系统.pdf");
    310.        
    311.        
    312.       
    313.       
    314.       
    315.       
    316.        
    317.                 
    318.         
    319.         FileOutputStream 
    320.         
    321.         fos 
    322.         
    323.         = 
    324.         
    325.         new 
    326.         
    327.         FileOutputStream(
    328.         
    329.         "深入理解计算机操作系统-副本.pdf")) {
    330.        
    331.        
    332.       
    333.       
    334.       
    335.       
    336.        
    337.                
    338.         
    339.         int len;
    340.        
    341.        
    342.       
    343.       
    344.       
    345.       
    346.        
    347.                
    348.         
    349.         byte[] bytes = 
    350.         
    351.         new 
    352.         
    353.         byte[
    354.         
    355.         4 * 
    356.         
    357.         1024];
    358.        
    359.        
    360.       
    361.       
    362.       
    363.       
    364.        
    365.                
    366.         
    367.         while ((len = fis.read(bytes)) != -
    368.         
    369.         1) {
    370.        
    371.        
    372.       
    373.       
    374.       
    375.       
    376.        
    377.        
    378.         
    379.                     fos.write(bytes, 
    380.         
    381.         0, len);
    382.        
    383.        
    384.       
    385.       
    386.       
    387.       
    388.        
    389.        
    390.         
    391.                 }
    392.        
    393.        
    394.       
    395.       
    396.       
    397.       
    398.        
    399.        
    400.         
    401.             } 
    402.         
    403.         catch (IOException e) {
    404.        
    405.        
    406.       
    407.       
    408.       
    409.       
    410.        
    411.        
    412.         
    413.                 e.printStackTrace();
    414.        
    415.        
    416.       
    417.       
    418.       
    419.       
    420.        
    421.        
    422.         
    423.             }
    424.        
    425.        
    426.       
    427.       
    428.       
    429.       
    430.        
    431.            
    432.         
    433.         // 记录结束时间
    434.        
    435.        
    436.       
    437.       
    438.       
    439.       
    440.        
    441.            
    442.         
    443.         long 
    444.         
    445.         end 
    446.         
    447.         = System.currentTimeMillis();
    448.        
    449.        
    450.       
    451.       
    452.       
    453.       
    454.        
    455.        
    456.         
    457.             System.out.println(
    458.         
    459.         "使用普通流复制PDF文件总耗时:" + (end - start) + 
    460.         
    461.         " 毫秒");
    462.        
    463.        
    464.       
    465.       
    466.       
    467.       
    468.        
    469.        
    470.         
    471.         }
    472.        
    473.        
    474.

    BufferedInputStream(字节缓冲输入流)

    BufferedInputStream 从源头(通常是文件)读取数据(字节信息)到内存的过程中不会一个字节一个字节的读取，而是会先将读取到的字节存放在缓存区，并从内部缓冲区中单独读取字节。这样大幅减少了 IO 次数，提高了读取效率。

    BufferedInputStream 内部维护了一个缓冲区，这个缓冲区实际就是一个字节数组，通过阅读 BufferedInputStream 源码即可得到这个结论。

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         public
    10.        
    11.        
    12.       
    13.       
    14.       
    15.       
    16.        
    17.        
    18.         
    19.         class BufferedInputStream extends FilterInputStream {
    20.        
    21.        
    22.       
    23.       
    24.       
    25.       
    26.        
    27.            
    28.         
    29.         // 内部缓冲区数组
    30.        
    31.        
    32.       
    33.       
    34.       
    35.       
    36.        
    37.            
    38.         
    39.         protected volatile byte buf[];
    40.        
    41.        
    42.       
    43.       
    44.       
    45.       
    46.        
    47.            
    48.         
    49.         // 缓冲区的默认大小
    50.        
    51.        
    52.       
    53.       
    54.       
    55.       
    56.        
    57.            
    58.         
    59.         private static int 
    60.         
    61.         DEFAULT_BUFFER_SIZE = 
    62.         
    63.         8192;
    64.        
    65.        
    66.       
    67.       
    68.       
    69.       
    70.        
    71.            
    72.         
    73.         // 使用默认的缓冲区大小
    74.        
    75.        
    76.       
    77.       
    78.       
    79.       
    80.        
    81.        
    82.         
    83.             public 
    84.         
    85.         BufferedInputStream(
    86.         
    87.         InputStream in) {
    88.        
    89.        
    90.       
    91.       
    92.       
    93.       
    94.        
    95.                
    96.         
    97.         this(in, 
    98.         
    99.         DEFAULT_BUFFER_SIZE);
    100.        
    101.        
    102.       
    103.       
    104.       
    105.       
    106.        
    107.        
    108.         
    109.             }
    110.        
    111.        
    112.       
    113.       
    114.       
    115.       
    116.        
    117.            
    118.         
    119.         // 自定义缓冲区大小
    120.        
    121.        
    122.       
    123.       
    124.       
    125.       
    126.        
    127.        
    128.         
    129.             public 
    130.         
    131.         BufferedInputStream(
    132.         
    133.         InputStream in, int size) {
    134.        
    135.        
    136.       
    137.       
    138.       
    139.       
    140.        
    141.                
    142.         
    143.         super(in);
    144.        
    145.        
    146.       
    147.       
    148.       
    149.       
    150.        
    151.                
    152.         
    153.         if (size <= 
    154.         
    155.         0) {
    156.        
    157.        
    158.       
    159.       
    160.       
    161.       
    162.        
    163.                    
    164.         
    165.         throw 
    166.         
    167.         new 
    168.         
    169.         IllegalArgumentException(
    170.         
    171.         "Buffer size <= 0");
    172.        
    173.        
    174.       
    175.       
    176.       
    177.       
    178.        
    179.        
    180.         
    181.                 }
    182.        
    183.        
    184.       
    185.       
    186.       
    187.       
    188.        
    189.        
    190.         
    191.                 buf = 
    192.         
    193.         new byte[size];
    194.        
    195.        
    196.       
    197.       
    198.       
    199.       
    200.        
    201.        
    202.         
    203.             }
    204.        
    205.        
    206.       
    207.       
    208.       
    209.       
    210.        
    211.        
    212.         
    213.         }
    214.        
    215.        
    216.

    缓冲区的大小默认为 8192 字节，当然了，你也可以通过 BufferedInputStream(InputStream in, int size) 这个构造方法来指定缓冲区的大小。

    BufferedOutputStream(字节缓冲输出流)

    BufferedOutputStream 将数据(字节信息)写入到目的地(通常是文件)的过程中不会一个字节一个字节的写入，而是会先将要写入的字节存放在缓存区，并从内部缓冲区中单独写入字节。这样大幅减少了 IO 次数，提高了读取效率

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         try (BufferedOutputStream bos = 
    10.         
    11.         new 
    12.         
    13.         BufferedOutputStream(
    14.         
    15.         new 
    16.         
    17.         FileOutputStream(
    18.         
    19.         "output.txt"))) {
    20.        
    21.        
    22.       
    23.       
    24.       
    25.       
    26.        
    27.        
    28.         
    29.             byte[] 
    30.         
    31.         array = 
    32.         
    33.         "JavaGuide".
    34.         
    35.         getBytes();
    36.        
    37.        
    38.       
    39.       
    40.       
    41.       
    42.        
    43.        
    44.         
    45.             bos.
    46.         
    47.         write(
    48.         
    49.         array);
    50.        
    51.        
    52.       
    53.       
    54.       
    55.       
    56.        
    57.        
    58.         
    59.         } 
    60.         
    61.         catch (IOException e) {
    62.        
    63.        
    64.       
    65.       
    66.       
    67.       
    68.        
    69.        
    70.         
    71.             e.
    72.         
    73.         printStackTrace();
    74.        
    75.        
    76.       
    77.       
    78.       
    79.       
    80.        
    81.        
    82.         
    83.         }
    84.        
    85.        
    86.

    类似于 BufferedInputStream ， BufferedOutputStream 内部也维护了一个缓冲区，并且，这个缓存区的大小也是 8192 字节。

    字符缓冲流

    BufferedReader (字符缓冲输入流)和 BufferedWriter (字符缓冲输出流)类似于 BufferedInputStream (字节缓冲输入流)和 BufferedOutputStream (字节缓冲输入流)，内部都维护了一个字节数组作为缓冲区。不过，前者主要是用来操作字符信息。

    打印流

    下面这段代码大家经常使用吧？

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         System.
    10.         
    11.         out.print(
    12.         
    13.         "Hello！");
    14.        
    15.        
    16.       
    17.       
    18.       
    19.       
    20.        
    21.        
    22.         
    23.         System.
    24.         
    25.         out.println(
    26.         
    27.         "Hello！");
    28.        
    29.        
    30.

    System.out 实际是用于获取一个 PrintStream 对象， print 方法实际调用的是 PrintStream 对象的 write 方法。

    PrintStream 属于字节打印流，与之对应的是 PrintWriter (字符打印流)。 PrintStream 是 OutputStream 的子类， PrintWriter 是 Writer 的子类。

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         public 
    10.         
    11.         class PrintStream extends FilterOutputStream
    12.        
    13.        
    14.       
    15.       
    16.       
    17.       
    18.        
    19.        
    20.         
    21.             implements 
    22.         
    23.         Appendable, 
    24.         
    25.         Closeable {
    26.        
    27.        
    28.       
    29.       
    30.       
    31.       
    32.        
    33.        
    34.         
    35.         }
    36.        
    37.        
    38.       
    39.       
    40.       
    41.       
    42.        
    43.        
    44.         
    45.         public 
    46.         
    47.         class PrintWriter extends Writer {
    48.        
    49.        
    50.       
    51.       
    52.       
    53.       
    54.        
    55.        
    56.         
    57.         }
    58.        
    59.        
    60.

    随机访问流

    这里要介绍的随机访问流指的是支持随意跳转到文件的任意位置进行读写的 RandomAccessFile 。

    RandomAccessFile 的构造方法如下，我们可以指定 mode (读写模式)。

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         // openAndDelete 参数默认为 false 表示打开文件并且这个文件不会被删除
    10.        
    11.        
    12.       
    13.       
    14.       
    15.       
    16.        
    17.        
    18.         
    19.         public 
    20.         
    21.         RandomAccessFile
    22.         
    23.         (File file, String mode)
    24.        
    25.        
    26.       
    27.       
    28.       
    29.       
    30.        
    31.            
    32.         
    33.         throws FileNotFoundException {
    34.        
    35.        
    36.       
    37.       
    38.       
    39.       
    40.        
    41.            
    42.         
    43.         this(file, mode, 
    44.         
    45.         false);
    46.        
    47.        
    48.       
    49.       
    50.       
    51.       
    52.        
    53.        
    54.         
    55.         }
    56.        
    57.        
    58.       
    59.       
    60.       
    61.       
    62.        
    63.        
    64.         
    65.         // 私有方法
    66.        
    67.        
    68.       
    69.       
    70.       
    71.       
    72.        
    73.        
    74.         
    75.         private 
    76.         
    77.         RandomAccessFile
    78.         
    79.         (File file, String mode, boolean openAndDelete)  
    80.         
    81.         throws FileNotFoundException{
    82.        
    83.        
    84.       
    85.       
    86.       
    87.       
    88.        
    89.          
    90.         
    91.         // 省略大部分代码
    92.        
    93.        
    94.       
    95.       
    96.       
    97.       
    98.        
    99.        
    100.         
    101.         }
    102.        
    103.        
    104.

    读写模式主要有下面四种：

    • r : 只读模式。

    • rw : 读写模式

      1. rws
      2. rw
      3. rws
       
      1. rwd
      2. rw
      3. rwd

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

    RandomAccessFile 中有一个文件指针用来表示下一个将要被写入或者读取的字节所处的位置。我们可以通过 RandomAccessFile 的 seek(long pos) 方法来设置文件指针的偏移量(距文件开头 pos 个字节处)。如果想要获取文件指针当前的位置的话，可以使用 getFilePointer() 方法。

    RandomAccessFile 代码示例：

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         RandomAccessFile randomAccessFile = 
    10.         
    11.         new RandomAccessFile(
    12.         
    13.         new File(
    14.         
    15.         "input.txt"), 
    16.         
    17.         "rw");
    18.        
    19.        
    20.       
    21.       
    22.       
    23.       
    24.        
    25.        
    26.         
    27.         System.
    28.         
    29.         out.println(
    30.         
    31.         "读取之前的偏移量：" + randomAccessFile.getFilePointer() + 
    32.         
    33.         ",当前读取到的字符" + (
    34.         
    35.         char) randomAccessFile.read() + 
    36.         
    37.         "，读取之后的偏移量：" + randomAccessFile.getFilePointer());
    38.        
    39.        
    40.       
    41.       
    42.       
    43.       
    44.        
    45.        
    46.         
    47.         // 指针当前偏移量为 6
    48.        
    49.        
    50.       
    51.       
    52.       
    53.       
    54.        
    55.        
    56.         
    57.         randomAccessFile.seek(
    58.         
    59.         6);
    60.        
    61.        
    62.       
    63.       
    64.       
    65.       
    66.        
    67.        
    68.         
    69.         System.
    70.         
    71.         out.println(
    72.         
    73.         "读取之前的偏移量：" + randomAccessFile.getFilePointer() + 
    74.         
    75.         ",当前读取到的字符" + (
    76.         
    77.         char) randomAccessFile.read() + 
    78.         
    79.         "，读取之后的偏移量：" + randomAccessFile.getFilePointer());
    80.        
    81.        
    82.       
    83.       
    84.       
    85.       
    86.        
    87.        
    88.         
    89.         // 从偏移量 7 的位置开始往后写入字节数据
    90.        
    91.        
    92.       
    93.       
    94.       
    95.       
    96.        
    97.        
    98.         
    99.         randomAccessFile.write(
    100.         
    101.         new 
    102.         
    103.         byte[]{
    104.         
    105.         'H', 
    106.         
    107.         'I', 
    108.         
    109.         'J', 
    110.         
    111.         'K'});
    112.        
    113.        
    114.       
    115.       
    116.       
    117.       
    118.        
    119.        
    120.         
    121.         // 指针当前偏移量为 0，回到起始位置
    122.        
    123.        
    124.       
    125.       
    126.       
    127.       
    128.        
    129.        
    130.         
    131.         randomAccessFile.seek(
    132.         
    133.         0);
    134.        
    135.        
    136.       
    137.       
    138.       
    139.       
    140.        
    141.        
    142.         
    143.         System.
    144.         
    145.         out.println(
    146.         
    147.         "读取之前的偏移量：" + randomAccessFile.getFilePointer() + 
    148.         
    149.         ",当前读取到的字符" + (
    150.         
    151.         char) randomAccessFile.read() + 
    152.         
    153.         "，读取之后的偏移量：" + randomAccessFile.getFilePointer());
    154.        
    155.        
    156.

    input.txt 文件内容：

    输出：

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         读取之前的偏移量：
    10.         
    11.         0,当前读取到的字符
    12.         
    13.         A，读取之后的偏移量：
    14.         
    15.         1
    16.        
    17.        
    18.       
    19.       
    20.       
    21.       
    22.        
    23.        
    24.         
    25.         读取之前的偏移量：
    26.         
    27.         6,当前读取到的字符G，读取之后的偏移量：
    28.         
    29.         7
    30.        
    31.        
    32.       
    33.       
    34.       
    35.       
    36.        
    37.        
    38.         
    39.         读取之前的偏移量：
    40.         
    41.         0,当前读取到的字符
    42.         
    43.         A，读取之后的偏移量：
    44.         
    45.         1
    46.        
    47.        
    48.

    input.txt 文件内容变为 ABCDEFGHIJK 。

    RandomAccessFile 的 write 方法在写入对象的时候如果对应的位置已经有数据的话，会将其覆盖掉。

    1.  
    2.     
    3.     
    4.       
    5.       
    6.        
    7.        
    8.         
    9.         RandomAccessFile randomAccessFile = 
    10.         
    11.         new RandomAccessFile(
    12.         
    13.         new File(
    14.         
    15.         "input.txt"), 
    16.         
    17.         "rw");
    18.        
    19.        
    20.       
    21.       
    22.       
    23.       
    24.        
    25.        
    26.         
    27.         randomAccessFile.write(
    28.         
    29.         new 
    30.         
    31.         byte[]{
    32.         
    33.         'H', 
    34.         
    35.         'I', 
    36.         
    37.         'J', 
    38.         
    39.         'K'});
    40.        
    41.        
    42.

    假设运行上面这段程序之前 input.txt 文件内容变为 ABCD ，运行之后则变为 HIJK 。

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

    RandomAccessFile 可以帮助我们合并文件分片，示例代码如下：

    我在《Java 面试指北》中详细介绍了大文件的上传问题。

    RandomAccessFile 的实现依赖于 FileDescriptor (文件描述符) 和 FileChannel (内存映射文件)。

    ··········  END  ··············

    来源：https://blog.csdn.net/lt_xiaodou/article/details/126666019
  • 相关阅读:
    如何保障汽车嵌入式软件的质量与安全？您需要了解ASPICE标准
    ospf综合实验
    JavaFx 实现水平滚动文本(跑马灯效果)
    【Java】List接口中泛型如何实现
    【SpringBoot教程】SpringBoot+MybatisPlus数据库连接测试 用户收货信息接口开发
    Java---Stream流详解
    Spring框架系列 - 深入浅出SpringMVC请求流程和案例
    thinkphp5 redis使用
    【计算机考研必备常识】24考研你开始准备了吗？
    [科普文] Web3 中的资产负债表
  • 原文地址：https://blog.csdn.net/china_coding/article/details/126925299