第十七章 二进制IO

第十七章 二进制I/O

17.1 引言

Java 提供了许多类用于实现文本 I/0 和二进制 IO。

文件可以分为文本或者二进制的。可以使用文本编辑器，比如Windows下的记事本或者UNIX下的vi编辑器，进行处理(读取、创建或者修改)的文件称为文本文件。所有其他的文件称为二进制文件。不能使用文本编辑器来读取二进制文件–它们被设计为使用程序来读取。例如，Java源程序存储在文本文件中，可以使用文本编辑器读取，而Java类文件是二进制文件，由Java虚拟机读取。

Java提供了许多实现文件输入/输出的类。这些类可以分为文本I/O类(text I/O class)和二进制I/O类(binary I/O class)。

17.2 Java如何处理文本I/O

使用Scanner类读取文本数据，使用PrintWriter类写文本数据。

File对象封装了文件或路径属性，但是不包含从/向文件读/写数据的方法为了进行I/O操作，需要使用正确的Java I/O类创建对象。这些对象包含从/向文件中读写数据的方法。例如，为了将文本写入一个名为temp.txt的文件中，可以使用Printwriter类按如下方式创建一个对象：

PrintWriter output = new PrintWriter("temp.txt");

现在，可以调用该对象的 print 方法向文件写人一个字符串。例如，下面的语句将 Java101 写入这个文件中。

Java有许多用于各种目的的I/O类。通常，可以将它们分为输人类和输出类。输入类包含读数据的方法，而输出类包含写数据的方法。Printwriter是一个输出类的例子，而Scanner 是一个输人类的例子。下面的代码为文件temp.txt创建一个输人对象，并从该文件中读取数据：

output.print("Java 101");

下面的语句关闭这个文件。

output.close();

Java有许多用于各种目的的I/O类。通常，可以将它们分为输入类和输出类。输入类包含读数据的方法，而输出类包含写数据的方法。Printwriter是一个输出类的例子，而Scanner是一个输人类的例子。下面的代码为文件temp.txt创建一个输入对象，并从该文件中读取数据：

Scanner input = new Scanner(newFile("temp.txt"));
System.out.println(input.nextLine());

如果文件temp.txt 中包含文本"Java 101"，那么input.nextLine()方法就会返回字符串"Java 101"。

下图展示了Java I/O程序设计。输人对象从文件中读取数据流，输出对象将数据流写入文件。输入对象也称作输入流(input stream)。同样，输出对象也称作输出流(output stream)。

17.3 文本I/O与二进制I/O

二进制 I/O 不涉及编码和解码，因此比文本 I/O 更加高效。

计算机并不区分二进制文件和文本文件。所有的文件都是以二进制形式来存储的，因此，从本质上说，所有的文件都是二进制文件。文本I/O建立在二进制I/O的基础之上，它能提供一层抽象，用于字符的编码和解码，如下图所示。对于文本 I/O 而言，编码和解码是自动进行的。在写入字符时，Java虚拟机会将Unicode码转化为文件特定的编码，而在读取字符时，将文件特定的编码转化为Unicode码。例如，假设使用文本I/O将字符串"199"写人文件，那么每个字符都会写入文件中。由于字符1的Unicode编码为 0x0031，所以会根据文件的编码方案将Unicode码0x0031转化成一个编码。(注意，前缀0x表示十六进制数。)在美国，Windows系统中文本文件的默认编码方案是ASCII码。字符1的ASCII码是49(十六进制表示为0x31)，而字符9的ASCII码是57(十六进制表示为 0x39)。所以为了以字符写入 199，应该将三个字节0x31、0x39和 0x39 发送到输出，如下图所示。

二进制I/O不需要转化。如果使用二进制I/O向文件写人一个数值，就是将内存中的那个值复制到文件中。例如，一个字节类型的数值199在内存中表示为0xC7(199=12x16’+7)，并且在文件中实际出现的也是 0xC7，如上图所示。使用二进制 I/O 读取一个字节时，就会从输人流中读取一个字节的值。

一般来说，对于文本编辑器或文本输出程序创建的文件，应该使用文本输入来读取，对于 Java 二进制输出程序创建的文件，应该使用二进制输入来读取。由于二进制 I/O 不需要编码和解码，所以，它比文本 I/O 效率高。二进制文件与主机的编码方案无关，因此，它是可移植的。任何机器上的Java程序都可以读取Java程序所创建的二进制文件。这就是为什么Java的类文件存储为二进制文件的原因。Java类文件可以在任何具有Java虚拟机的机器上运行。

17.4 二进制I/O类

抽象类InputStream 是读取二进制数据的根类，抽象类OutputStream是写入二进制数据的根类。

Java I/O 类的设计是一个很好的应用继承的例子，它们的公共操作在父类中泛化定义,而子类提供特定的操作。如下图列出了一些执行二进制I/O的类。

Inputstream 类是二进制输入类的根类，而OutputStream类是二进制输出类的根类。下图列出了InputStream类和OutputStream类的所有方法。

注意：二进制I/O类中的所有方法都声明为抛出java.io.IOException或java.iO.IOException 的子类。

17.4.1 FileInputStream和FileOutputStream

FileInputstream类和FileOutputstream类用于从/向文件读取/写入字节。它们的所有方法都是从InputStream类和OutputStream类继承的。FileInputStream类和FileOutputStream 类没有引入新的方法。为了构造一个FileInputstream 对象，使用下面的构造方法，如下图所示。

如果试图为一个不存在的文件创建FileInputstream对象，将会发生java.io.FileNotFoundException异常。

要构造一个FileOutputstream 对象，使用如下图所示的构造方法。

如果该文件不存在，就会创建一个新文件。如果该文件已经存在，前两个构造方法将会删除文件的当前内容。为了既保留文件现有的内容又可以给文件追加新数据，将最后两个构造方法中的append参数设置为true。

几乎所有的I/O类中的方法都会抛出异常java.io.IOException。因此，必须在方法中声明会抛出 java.io.IOException 异常，或者将代码放到try-catch块中，如下所示：

下面使用二进制I/O将1到10的10个字节值写入一个名为temp.dat 的文件,
再把它们从文件中读出来。

import java.io.*;

public class TestFileStream{
    public static void main(String[]args) throws IOException {
        try(
            //Create an output stream to the file
            Fi1e0utputStream output = new File0utputStream("temp.dat");
        ) {
            //0utput values to the file
            for(int i = 1; i <= 10; i++)
                output.write(i);
        }
            
        try (
            //Create an input stream for the file
            FileInputStream input = new FileInputStream("temp .dat");) {
            // Read values from the file
            int value;
            while ((value = input.read()) != -1)
           		System.out.print(value + " ");
       }
    }
}

输出结果如下：

程序使用了try-with-resources来声明和创建输入输出流，从而在使用后可以自动关闭。java.io.InputStream和java.io.OutputStream实现了AutoClosable接口。AutoClosable接口定义了close()方法，用于关闭资源。任何Autoclosable类型的对象都可以用于try-with-resources语法中，实现自动关闭。

第7行为文件temp.dat创建了一个File0utputstream对象。for循环将10个字节值写入文件(第10和11行)。调用write(i)方法与调用write((byte)i)具有相同的功能。第16行为文件 temp.dat 创建了一个FileInputstream对象。第19~21行从文件中读取字节值并在控制台上显示出来。表达式((value = input.read()) != -1)(第20行)通过input.read()读取一个字节，然后将它赋值给value，并且检验它是否为-1。输入值为 -1 意味着文件的结束。

17.4.2 FilterInputStream和FilterOutputStream

过滤器数据流(flter stream)是为某种目的过滤字节的数据流。基本字节输入流提供的读取方法read只能用来读取字节。如果要读取整数值、双精度值或字符串，那就需要一个过滤器类来包装字节输入流。使用过滤器类就可以读取整数值、双精度值和字符串，而不是字节或字符。FilterInputStream类和FilterOutputstream 类是用于过滤数据的基类。需要处理基本数值类型时，就使用 DataInputStream 类和 DataOutputstream 类来过滤字节。

17.4.3 DataInputStream 和DataOutputStream

DataInputstream 从数据流读取字节，并且将它们转换为合适的基本类型值或字符串。DataOutputstream将 基本类型的值或字符串转换为字节，并且将字节输出到流。DataInputStream 类继承自 FilterInputStream 类，并实现 DataInput 接口，如下图所示 DataOutputStream 类继承自FilterOutputStream 类，并实现 DataOutput 接口，如下图所示。

DataInputstream 实现了定义在DataInput接口中的方法来读取基本数据类型值和字符串。DataOutputstream实现了定义在 DataOutput 接口中的方法来写入基本数据类型值和字符串。基本类型的值不需要做任何转化就可以从内存复制到输出数据流。

17.4.4 BufferedInputStream和BufferedOutputStream

BufferedInputStream 类和 BufferedOutputStream 类可以通过减少磁盘读写次数来提高输入和输出的速度。使用BufferdInputstream 时，磁盘上的整块数据一次性地读人内存的缓冲区中。然后从缓冲区中将单个数据传递到程序中，如下图所示。使用Buffered-OutputStream，单个数据首先写人内存的缓冲区中。当缓冲区已满时，缓冲区中的所有数据一次性写人磁盘中，如下图所示。

BufferedInputStream类和BufferedOutputStream类没有包含新的方法。BufferedInput-Stream 类和 BufferedOutputStream中的所有方法都是从InputStream类和OutputStream类继承而来的。BufferedInputStream类和BufferedOutputStream类在后台管理了一个缓冲区，根据需求自动从磁盘中读取数据和写人数据。

可以使用如下图和下图所示的构造方法将任何一个Inputstream类和Output-Stream类包装为BufferedInputStream类和BufferedOutputStream类。

17.5 示例学习：复制文件

**需求：**复制文件

**思路：**编写一个支持用户复制文件的程序。用户需要提供一个源文件与一个目标文件作为命令行参数，所使用的命令如下：

java Copy source target

该程序将源文件复制到目标文件，然后显示这个文件中的字节数。如果源文件不存在，或者目标文件已经存在，程序应该给用户相应的提示。这个程序的一个运行示例如下图所示。

要把源文件的内容复制到目标文件，不管文件的内容如何，使用输入流从源文件读出字节，并且使用输出流将字节写人目标文件比较合适。源文件和目标文件都是在命令行中指定的。为源文件创建一个InputFileStream对象，为目标文件创建一个OutputFilestream对象。使用read()方法从输人流中读取一个字节，使用write(b)方法将一个字节写入输出流使用BufferedInputStream类和BufferedOutputStream类来提高执行效率。下面给出这个问题的解决方案。

具体实现：

import java.io.*
public class Copy{
    /**Main method
    @param args[0] for sourcefile
    @param args[i] for target file
   */ 
    public static void main(String[]args) throws I0Exception{
        //Check command-line parameter usage
        if(args.length!=2){
            System.out.printin(
                "Usage:java Copy sourceFile targetfile");
            System.exit(1);
        }

        //Check if source file exists
        File sourceFile = new File(args[0]);
        if(!sourceFile.exists()){
            System.out.printin("Source file"+ args[0] + " does not exist");
            System.exit(2):

        }
        //Check if target file exists
        File targetFile = new File(args[1]);
        if(targetFile.exists()){
            System.out.printin("Target file"+ args[1]+" already exists");
            System.exit(3);
        }

        try(
            //Create an input stream

            BufferedInputStream input = new BufferedInputStream(new FieInputStream(sourceFile));

            //Create an output stream
            BufferedOutputStream outputnew BufferedOutputStream(new File0utputStream(targetFi1e));
            ){
            //Continuously read a byte from input and write it to output
            int r, numberOfBytesCopied=0;
            whi1e((r=input.read())1=-1){
                output.write((byte)r);
                numberOfBytesCopied++;
            }
            // Display the file size
            System.out.printIn(numberOfBytesCopied +" bytes copied");
        }
    }
}

17.6 对象I/O

ObjectInputStream类和ObjectOutputStream类可以用于读/写可序列化的对象DataInputStream类和 DataOutputstream类可以实现基本数据类型与字符串的输入和输出。而ObjectInputStream类和ObjectOutputStream类除了可以实现基本数据类型与字符串的输入和输出之外，还可以实现对象的输入和输出。由于ObjectInputstream类和ObjectOutputStream类包含DataInputStream类和DataOutputStream类的所有功能，所以，完全可以用ObjectInputStream类和ObjectOutputStream类代替 DataInputStream 类和DataOutputStream类

ObjectInputStream继承自InputStream类，并实现了接口ObjectInput和ObjectStream-Constants，如下图所示。ObjectInput是DataInput的子接口(DataInput如下图所示)ObjectStreamConstants包含了支持ObjectInputStream类和 Object0utputStream 类的常量。

ObjectOutputStream继承自OutputStream类，并实现了接口Object0utput与Object-StreamConstants，如下图所示。ObjectOutput是DataOutput的子接口(DataOutput 如下图所示)。

17.6.1 Serializable接口

并不是每一个对象都可以写到输出流。可以写到输出流中的对象称为可序列化的serializable)。因为可序列化的对象是 java.io.serializable接口的实例，所以，可序列化对象的类必须实现 Serializable接口。

Serializable接口是一种标记接口。因为它没有方法，所以，不需要在类中为实现Serializable接口增加额外的代码。实现这个接口可以启动Java的序列化机制，自动完成存储对象和数组的过程。

为了体会这个自动功能和理解对象是如何存储的，考虑一下不使用这一功能，储存一个对象需要做哪些工作。假设要存储一个ArrayList对象。为了完成这个任务，需要存储列表中的每个元素。每个元素是一个可能包含其他对象的对象。如你所见，这是一个非常烦琐冗长的过程。幸运的是，不必手工完成这个过程。Java提供一个内在机制自动完成写对象的过程。这个过程称为对象序列化(objecserialization)，它是在ObjectOutputstream中实现的。与此相反，读取对象的过程称作对象反序列化(Objectdeserialization)，它是在ObjectInputStream类中实现的。

许多JavaAPI中的类都实现了Serializable接口。所有针对基本类型值的包装类，java.math.BigInteger、java.math.BigDecimal、java.lang.String、java.langStringBuilder、java.lang.StringBuffer、java.util.Date 以及java.util.ArrayList 都实现了 java.io.Serializable接口。试图存储一个不支持 Serializable接口的对象会引起一个NotSerializableException异常。当存储一个可序列化对象时，会对该对象的类进行编码。编码包括类名、类的签名、对象实例变量的值以及该对象引用的任何其他对象的闭包，但是不存储对象静态变量的值。

17.6.2 序列化数组

如果数组中的所有元素都是可序列化的，这个数组就是可序列化的。整个数组可以用writeObject方法存入文件，随后用readObject方法恢复。下面代码中存储由五个int元素构成的数组和由三个字符串构成的数组，然后将它们从文件中读回来显示在控制台上。

运行结果如下：