java编程思想(第四版)_第10章 Java IO系统

原创 2007年10月08日 13:44:00
-------------------------------------------------

本教程由yyc,spirit整理

-------------------------------------------------




“对语言设计人员来说,创建好的输入/输出系统是一项特别困难的任务。”

由于存在大量不同的设计方案,所以该任务的困难性是很容易证明的。其中最大的挑战似乎是如何覆盖所有可能的因素。不仅有三种不同的种类的IO需要考虑(文件、控制台、网络连接),而且需要通过大量不同的方式与它们通信(顺序、随机访问、二进制、字符、按行、按字等等)。
Java库的设计者通过创建大量类来攻克这个难题。事实上,Java的IO系统采用了如此多的类,以致刚开始会产生不知从何处入手的感觉(具有讽刺意味的是,Java的IO设计初衷实际要求避免过多的类)。从Java 1.0升级到Java 1.1后,IO库的设计也发生了显著的变化。此时并非简单地用新库替换旧库,Sun的设计人员对原来的库进行了大手笔的扩展,添加了大量新的内容。因此,我们有时不得不混合使用新库与旧库,产生令人无奈的复杂代码。
本章将帮助大家理解标准Java库内的各种IO类,并学习如何使用它们。本章的第一部分将介绍“旧”的Java 1.0 IO流库,因为现在有大量代码仍在使用那个库。本章剩下的部分将为大家引入Java 1.1 IO库的一些新特性。注意若用Java 1.1编译器来编译本章第一部分介绍的部分代码,可能会得到一条“不建议使用该特性”(Deprecated feature)警告消息。代码仍然能够使用;编译器只是建议我们换用本章后面要讲述的一些新特性。但我们这样做是有价值的,因为可以更清楚地认识老方法与新方法之间的一些差异,从而加深我们的理解(并可顺利阅读为Java 1.0写的代码)。

10.1 输入和输出
可将Java库的IO类分割为输入与输出两个部分,这一点在用Web浏览器阅读联机Java类文档时便可知道。通过继承,从InputStream(输入流)衍生的所有类都拥有名为read()的基本方法,用于读取单个字节或者字节数组。类似地,从OutputStream衍生的所有类都拥有基本方法write(),用于写入单个字节或者字节数组。然而,我们通常不会用到这些方法;它们之所以存在,是因为更复杂的类可以利用它们,以便提供一个更有用的接口。因此,我们很少用单个类创建自己的系统对象。一般情况下,我们都是将多个对象重叠在一起,提供自己期望的功能。我们之所以感到Java的流库(Stream Library)异常复杂,正是由于为了创建单独一个结果流,却需要创建多个对象的缘故。
很有必要按照功能对类进行分类。库的设计者首先决定与输入有关的所有类都从InputStream继承,而与输出有关的所有类都从OutputStream继承。

10.1.1 InputStream的类型
InputStream的作用是标志那些从不同起源地产生输入的类。这些起源地包括(每个都有一个相关的InputStream子类):
(1) 字节数组
(2) String对象
(3) 文件
(4) “管道”,它的工作原理与现实生活中的管道类似:将一些东西置入一端,它们在另一端出来。 (5) 一系列其他流,以便我们将其统一收集到单独一个流内。
(6) 其他起源地,如Internet连接等(将在本书后面的部分讲述)。

除此以外,FilterInputStream也属于InputStream的一种类型,用它可为“破坏器”类提供一个基础类,以便将属性或者有用的接口同输入流连接到一起。这将在以后讨论。

Class

Function

Constructor Arguments

How to use it

ByteArray-InputStream

Allows a buffer in memory to be used as an InputStream.

The buffer from which to extract the bytes.

As a source of data. Connect it to a FilterInputStream object to provide a useful interface.

StringBuffer-InputStream

Converts a String into an InputStream.

A String. The underlying implementation actually uses a StringBuffer.

As a source of data. Connect it to a FilterInputStream object to provide a useful interface.

File-InputStream

For reading information from a file.

A String representing the file name, or a File or FileDescriptor object.

As a source of data. Connect it to a FilterInputStream object to provide a useful interface.


类 功能 构建器参数/如何使用

ByteArrayInputStream 允许内存中的一个缓冲区作为InputStream使用 从中提取字节的缓冲区/作为一个数据源使用。通过将其同一个FilterInputStream对象连接,可提供一个有用的接口
StringBufferInputStream 将一个String转换成InputStream 一个String(字串)。基础的实施方案实际采用一个StringBuffer(字串缓冲)/作为一个数据源使用。通过将其同一个FilterInputStream对象连接,可提供一个有用的接口
FileInputStream 用于从文件读取信息 代表文件名的一个String,或者一个File或FileDescriptor对象/作为一个数据源使用。通过将其同一个FilterInputStream对象连接,可提供一个有用的接口

Piped-InputStream

Produces the data that’s being written to the associated PipedOutput-Stream. Implements the “piping” concept.

PipedOutputStream

As a source of data in multithreading. Connect it to a FilterInputStream object to provide a useful interface.

Sequence-InputStream

Coverts two or more InputStream objects into a single InputStream.

Two InputStream objects or an Enumeration for a container of InputStream objects.

As a source of data. Connect it to a FilterInputStream object to provide a useful interface.

Filter-InputStream

Abstract class which is an interface for decorators that provide useful functionality to the other InputStream classes. See Table 10-3.

See Table 10-3.

See Table 10-3.


PipedInputString 产生为相关的PipedOutputStream写的数据。实现了“管道化”的概念 PipedOutputStream/作为一个数据源使用。通过将其同一个FilterInputStream对象连接,可提供一个有用的接口
SequenceInputStream 将两个或更多的InputStream对象转换成单个InputStream使用 两个InputStream对象或者一个Enumeration,用于InputStream对象的一个容器/作为一个数据源使用。通过将其同一个FilterInputStream对象连接,可提供一个有用的接口
FilterInputStream 对作为破坏器接口使用的类进行抽象;那个破坏器为其他InputStream类提供了有用的功能。参见表10.3 参见表10.3/参见表10.3

10.1.2 OutputStream的类型
这一类别包括的类决定了我们的输入往何处去:一个字节数组(但没有String;假定我们可用字节数组创建一个);一个文件;或者一个“管道”。
除此以外,FilterOutputStream为“破坏器”类提供了一个基础类,它将属性或者有用的接口同输出流连接起来。这将在以后讨论。
表10.2 OutputStream的类型

Class

Function

Constructor Arguments

How to use it

ByteArray-OutputStream

Creates a buffer in memory. All the data that you send to the stream is placed in this buffer.

Optional initial size of the buffer.

To designate the destination of your data. Connect it to a FilterOutputStream object to provide a useful interface.

File-OutputStream

For sending information to a file.

A String representing the file name, or a File or FileDescriptor object.

To designate the destination of your data. Connect it to a FilterOutputStream object to provide a useful interface.

Piped-OutputStream

Any information you write to this automatically ends up as input for the associated PipedInput-Stream. Implements the “piping” concept.

PipedInputStream

To designate the destination of your data for multithreading. Connect it to a FilterOutputStream object to provide a useful interface.

Filter-OutputStream

Abstract class which is an interface for decorators that provide useful functionality to the other OutputStream classes. See Table
10-4.

See Table 10-4.

See Table 10-4.


类 功能 构建器参数/如何使用

ByteArrayOutputStream 在内存中创建一个缓冲区。我们发送给流的所有数据都会置入这个缓冲区。 可选缓冲区的初始大小/用于指出数据的目的地。若将其同FilterOutputStream对象连接到一起,可提供一个有用的接口
FileOutputStream 将信息发给一个文件 用一个String代表文件名,或选用一个File或FileDescriptor对象/用于指出数据的目的地。若将其同FilterOutputStream对象连接到一起,可提供一个有用的接口
PipedOutputStream 我们写给它的任何信息都会自动成为相关的PipedInputStream的输出。实现了“管道化”的概念 PipedInputStream/为多线程处理指出自己数据的目的地/将其同FilterOutputStream对象连接到一起,便可提供一个有用的接口
FilterOutputStream 对作为破坏器接口使用的类进行抽象处理;那个破坏器为其他OutputStream类提供了有用的功能。参见表10.4 参见表10.4/参见表10.4

10.2 增添属性和有用的接口
利用层次化对象动态和透明地添加单个对象的能力的做法叫作“装饰器”(Decorator)方案——“方案”属于本书第16章的主题(注释①)。装饰器方案规定封装于初始化对象中的所有对象都拥有相同的接口,以便利用装饰器的“透明”性质——我们将相同的消息发给一个对象,无论它是否已被“装饰”。这正是在Java IO库里存在“过滤器”(Filter)类的原因:抽象的“过滤器”类是所有装饰器的基础类(装饰器必须拥有与它装饰的那个对象相同的接口,但装饰器亦可对接口作出扩展,这种情况见诸于几个特殊的“过滤器”类中)。
子类处理要求大量子类对每种可能的组合提供支持时,便经常会用到装饰器——由于组合形式太多,造成子类处理变得不切实际。Java IO库要求许多不同的特性组合方案,这正是装饰器方案显得特别有用的原因。但是,装饰器方案也有自己的一个缺点。在我们写一个程序的时候,装饰器为我们提供了大得多的灵活性(因为可以方便地混合与匹配属性),但它们也使自己的代码变得更加复杂。原因在于Java IO库操作不便,我们必须创建许多类——“核心”IO类型加上所有装饰器——才能得到自己希望的单个IO对象。
FilterInputStream和FilterOutputStream(这两个名字不十分直观)提供了相应的装饰器接口,用于控制一个特定的输入流(InputStream)或者输出流(OutputStream)。它们分别是从InputStream和OutputStream衍生出来的。此外,它们都属于抽象类,在理论上为我们与一个流的不同通信手段都提供了一个通用的接口。事实上,FilterInputStream和FilterOutputStream只是简单地模仿了自己的基础类,它们是一个装饰器的基本要求。

10.2.1 通过FilterInputStream从InputStream里读入数据
FilterInputStream类要完成两件全然不同的事情。其中,DataInputStream允许我们读取不同的基本类型数据以及String对象(所有方法都以“read”开头,比如readByte(),readFloat()等等)。伴随对应的DataOutputStream,我们可通过数据“流”将基本类型的数据从一个地方搬到另一个地方。这些“地方”是由表10.1总结的那些类决定的。若读取块内的数据,并自己进行解析,就不需要用到DataInputStream。但在其他许多情况下,我们一般都想用它对自己读入的数据进行自动格式化。
剩下的类用于修改InputStream的内部行为方式:是否进行缓冲,是否跟踪自己读入的数据行,以及是否能够推回一个字符等等。后两种类看起来特别象提供对构建一个编译器的支持(换言之,添加它们为了支持Java编译器的构建),所以在常规编程中一般都用不着它们。
也许几乎每次都要缓冲自己的输入,无论连接的是哪个IO设备。所以IO库最明智的做法就是将未缓冲输入作为一种特殊情况处理,同时将缓冲输入接纳为标准做法。
表10.3 FilterInputStream的类型

Class

Function

Constructor Arguments

How to use it

Data-InputStream

Used in concert with DataOutputStream, so you can read primitives (int, char, long, etc.) from a stream in a portable fashion.

InputStream

Contains a full interface to allow you to read primitive types.

Buffered-InputStream

Use this to prevent a physical read every time you want more data. You’re saying “Use a buffer.”

InputStream, with optional buffer size.

This doesn’t provide an interface per se, just a requirement that a buffer be used. Attach an interface object.

LineNumber-InputStream

Keeps track of line numbers in the input stream; you can call getLineNumber( ) and setLineNumber(int).

InputStream

This just adds line numbering, so you’ll probably attach an interface object.

Pushback-InputStream

Has a one byte push-back buffer so that you can push back the last character read.

InputStream

Generally used in the scanner for a compiler and probably included because the Java compiler needed it. You probably won’t use this.


类 功能 构建器参数/如何使用

DataInputStream 与DataOutputStream联合使用,使自己能以机动方式读取一个流中的基本数据类型(int,char,long等等) InputStream/包含了一个完整的接口,以便读取基本数据类型
BufferedInputStream 避免每次想要更多数据时都进行物理性的读取,告诉它“请先在缓冲区里找” InputStream,没有可选的缓冲区大小/本身并不能提供一个接口,只是发出使用缓冲区的要求。要求同一个接口对象连接到一起
LineNumberInputStream 跟踪输入流中的行号;可调用getLineNumber()以及setLineNumber(int) 只是添加对数据行编号的能力,所以可能需要同一个真正的接口对象连接
PushbackInputStream 有一个字节的后推缓冲区,以便后推读入的上一个字符 InputStream/通常由编译器在扫描器中使用,因为Java编译器需要它。一般不在自己的代码中使用

10.2.2 通过FilterOutputStream向OutputStream里写入数据
与DataInputStream对应的是DataOutputStream,后者对各个基本数据类型以及String对象进行格式化,并将其置入一个数据“流”中,以便任何机器上的DataInputStream都能正常地读取它们。所有方法都以“wirte”开头,例如writeByte(),writeFloat()等等。
若想进行一些真正的格式化输出,比如输出到控制台,请使用PrintStream。利用它可以打印出所有基本数据类型以及String对象,并可采用一种易于查看的格式。这与DataOutputStream正好相反,后者的目标是将那些数据置入一个数据流中,以便DataInputStream能够方便地重新构造它们。System.out静态对象是一个PrintStream。
PrintStream内两个重要的方法是print()和println()。它们已进行了覆盖处理,可打印出所有数据类型。print()和println()之间的差异是后者在操作完毕后会自动添加一个新行。
BufferedOutputStream属于一种“修改器”,用于指示数据流使用缓冲技术,使自己不必每次都向流内物理性地写入数据。通常都应将它应用于文件处理和控制器IO。
表10.4 FilterOutputStream的类型

Class

Function

Constructor Arguments

How to use it

Data-OutputStream

Used in concert with DataInputStream so you can write primitives (int, char, long, etc.) to a stream in a portable fashion.

OutputStream

Contains full interface to allow you to write primitive types.

PrintStream

For producing formatted output. While DataOutputStream handles the storage of data, PrintStream handles display.

OutputStream, with optional boolean indicating that the buffer is flushed with every newline.

Should be the “final” wrapping for your OutputStream object. You’ll probably use this a lot.

Buffered-OutputStream

Use this to prevent a physical write every time you send a piece of data. You’re saying “Use a buffer.” You can call flush( ) to flush the buffer.

OutputStream, with optional buffer size.

This doesn’t provide an interface per se, just a requirement that a buffer is used. Attach an interface object.


类 功能 构建器参数/如何使用

DataOutputStream 与DataInputStream配合使用,以便采用方便的形式将基本数据类型(int,char,long等)写入一个数据流 OutputStream/包含了完整接口,以便我们写入基本数据类型
PrintStream 用于产生格式化输出。DataOutputStream控制的是数据的“存储”,而PrintStream控制的是“显示” OutputStream,可选一个布尔参数,指示缓冲区是否与每个新行一同刷新/对于自己的OutputStream对象,应该用“final”将其封闭在内。可能经常都要用到它
BufferedOutputStream 用它避免每次发出数据的时候都要进行物理性的写入,要求它“请先在缓冲区里找”。可调用flush(),对缓冲区进行刷新 OutputStream,可选缓冲区大小/本身并不能提供一个接口,只是发出使用缓冲区的要求。需要同一个接口对象连接到一起

10.3 本身的缺陷:RandomAccessFile
RandomAccessFile用于包含了已知长度记录的文件,以便我们能用seek()从一条记录移至另一条;然后读取或修改那些记录。各记录的长度并不一定相同;只要知道它们有多大以及置于文件何处即可。
首先,我们有点难以相信RandomAccessFile不属于InputStream或者OutputStream分层结构的一部分。除了恰巧实现了DataInput以及DataOutput(这两者亦由DataInputStream和DataOutputStream实现)接口之外,它们与那些分层结构并无什么关系。它甚至没有用到现有InputStream或OutputStream类的功能——采用的是一个完全不相干的类。该类属于全新的设计,含有自己的全部(大多数为固有)方法。之所以要这样做,是因为RandomAccessFile拥有与其他IO类型完全不同的行为,因为我们可在一个文件里向前或向后移动。不管在哪种情况下,它都是独立运作的,作为Object的一个“直接继承人”使用。
从根本上说,RandomAccessFile类似DataInputStream和DataOutputStream的联合使用。其中,getFilePointer()用于了解当前在文件的什么地方,seek()用于移至文件内的一个新地点,而length()用于判断文件的最大长度。此外,构建器要求使用另一个自变量(与C的fopen()完全一样),指出自己只是随机读("r"),还是读写兼施("rw")。这里没有提供对“只写文件”的支持。也就是说,假如是从DataInputStream继承的,那么RandomAccessFile也有可能能很好地工作。
还有更难对付的。很容易想象我们有时要在其他类型的数据流中搜索,比如一个ByteArrayInputStream,但搜索方法只有RandomAccessFile才会提供。而后者只能针对文件才能操作,不能针对数据流操作。此时,BufferedInputStream确实允许我们标记一个位置(使用mark(),它的值容纳于单个内部变量中),并用reset()重设那个位置。但这些做法都存在限制,并不是特别有用。

10.4 File类
File类有一个欺骗性的名字——通常会认为它对付的是一个文件,但实情并非如此。它既代表一个特定文件的名字,也代表目录内一系列文件的名字。若代表一个文件集,便可用list()方法查询这个集,返回的是一个字串数组。之所以要返回一个数组,而非某个灵活的集合类,是因为元素的数量是固定的。而且若想得到一个不同的目录列表,只需创建一个不同的File对象即可。事实上,“FilePath”(文件路径)似乎是一个更好的名字。本节将向大家完整地例示如何使用这个类,其中包括相关的FilenameFilter(文件名过滤器)接口。

10.4.1 目录列表器
现在假设我们想观看一个目录列表。可用两种方式列出File对象。若在不含自变量(参数)的情况下调用list(),会获得File对象包含的一个完整列表。然而,若想对这个列表进行某些限制,就需要使用一个“目录过滤器”,该类的作用是指出应如何选择File对象来完成显示。
下面是用于这个例子的代码(或在执行该程序时遇到困难,请参考第3章3.1.2小节“赋值”):

 c10;
 java.io.*;

  DirList {
     main(String[] args) {
     {
      File path =  File();
      String[] list;
      (args.length == 0)
        list = path.list();
       
        list = path.list( DirFilter(args[0]));
      ( i = 0; i < list.length; i++)
        System.out.println(list[i]);
    } (Exception e) {
      e.printStackTrace();
    }
  }
}

 DirFilter  FilenameFilter {
  String afn;
  DirFilter(String afn) { .afn = afn; }
    accept(File dir, String name) {
    
    String f =  File(name).getName();
     f.indexOf(afn) != -1;
  }
} 

DirFilter类“实现”了interface FilenameFilter(关于接口的问题,已在第7章进行了详述)。下面让我们看看FilenameFilter接口有多么简单:

public interface FilenameFilter {
boolean accept(文件目录, 字串名);
}

它指出这种类型的所有对象都提供了一个名为accept()的方法。之所以要创建这样的一个类,背后的全部原因就是把accept()方法提供给list()方法,使list()能够“回调”accept(),从而判断应将哪些文件名包括到列表中。因此,通常将这种技术称为“回调”,有时也称为“算子”(也就是说,DirFilter是一个算子,因为它唯一的作用就是容纳一个方法)。由于list()采用一个FilenameFilter对象作为自己的自变量使用,所以我们能传递实现了FilenameFilter的任何类的一个对象,用它决定(甚至在运行期)list()方法的行为方式。回调的目的是在代码的行为上提供更大的灵活性。
通过DirFilter,我们看出尽管一个“接口”只包含了一系列方法,但并不局限于只能写那些方法(但是,至少必须提供一个接口内所有方法的定义。在这种情况下,DirFilter构建器也会创建)。
accept()方法必须接纳一个File对象,用它指示用于寻找一个特定文件的目录;并接纳一个String,其中包含了要寻找之文件的名字。可决定使用或忽略这两个参数之一,但有时至少要使用文件名。记住list()方法准备为目录对象中的每个文件名调用accept(),核实哪个应包含在内——具体由accept()返回的“布尔”结果决定。
为确定我们操作的只是文件名,其中没有包含路径信息,必须采用String对象,并在它的外部创建一个File对象。然后调用getName(),它的作用是去除所有路径信息(采用与平台无关的方式)。随后,accept()用String类的indexOf()方法检查文件名内部是否存在搜索字串"afn"。若在字串内找到afn,那么返回值就是afn的起点索引;但假如没有找到,返回值就是-1。注意这只是一个简单的字串搜索例子,未使用常见的表达式“通配符”方案,比如"fo?.b?r*";这种方案更难实现。
list()方法返回的是一个数组。可查询这个数组的长度,然后在其中遍历,选定数组元素。与C和C++的类似行为相比,这种于方法内外方便游历数组的行为无疑是一个显著的进步。

1. 匿名内部类
下例用一个匿名内部类(已在第7章讲述)来重写显得非常理想。首先创建了一个filter()方法,它返回指向FilenameFilter的一个句柄:

 java.io.*;

  DirList2 {
    FilenameFilter 
  filter( String afn) {
    
      FilenameFilter() {
      String fn = afn;
        accept(File dir, String n) {
        
        String f =  File(n).getName();
         f.indexOf(fn) != -1;
      }
    }; 
  }
     main(String[] args) {
     {
      File path =  File();
      String[] list;
      (args.length == 0)
        list = path.list();
       
        list = path.list(filter(args[0]));
      ( i = 0; i < list.length; i++)
        System.out.println(list[i]);
    } (Exception e) {
      e.printStackTrace();
    }
  }
} 

注意filter()的自变量必须是final。这一点是匿名内部类要求的,使其能使用来自本身作用域以外的一个对象。
之所以认为这样做更好,是由于FilenameFilter类现在同DirList2紧密地结合在一起。然而,我们可采取进一步的操作,将匿名内部类定义成list()的一个参数,使其显得更加精简。如下所示:

 java.io.*;

  DirList3 {
     main( String[] args) {
     {
      File path =  File();
      String[] list;
      (args.length == 0)
        list = path.list();
       
        list = path.list(
           FilenameFilter() {
              
            accept(File dir, String n) {
              String f =  File(n).getName();
               f.indexOf(args[0]) != -1;
            }
          });
      ( i = 0; i < list.length; i++)
        System.out.println(list[i]);
    } (Exception e) {
      e.printStackTrace();
    }
  }
} 

main()现在的自变量是final,因为匿名内部类直接使用args[0]。
这展示了如何利用匿名内部类快速创建精简的类,以便解决一些复杂的问题。由于Java中的所有东西都与类有关,所以它无疑是一种相当有用的编码技术。它的一个好处是将特定的问题隔离在一个地方统一解决。但在另一方面,这样生成的代码不是十分容易阅读,所以使用时必须慎重。

2. 顺序目录列表
经常都需要文件名以排好序的方式提供。由于Java 1.0和Java 1.1都没有提供对排序的支持(从Java 1.2开始提供),所以必须用第8章创建的SortVector将这一能力直接加入自己的程序。就象下面这样:

 java.io.*;
 c08.*;

  SortedDirList {
   File path;
   String[] list;
   SortedDirList( String afn) {
    path =  File();
    (afn == )
      list = path.list();
    
      list = path.list(
           FilenameFilter() {
              
            accept(File dir, String n) {
              String f =  File(n).getName();
               f.indexOf(afn) != -1;
            }
          });
    sort();
  }
   print() {
    ( i = 0; i < list.length; i++)
      System.out.println(list[i]);
  }
    sort() {
    StrSortVector sv =  StrSortVector();
    ( i = 0; i < list.length; i++)
      sv.addElement(list[i]);
    
    
    ( i = 0; i < list.length; i++)
      list[i] = sv.elementAt(i);
  }
  
     main(String[] args) {
    SortedDirList sd;
    (args.length == 0)
      sd =  SortedDirList();
    
      sd =  SortedDirList(args[0]);
    sd.print();
  }
} 

这里进行了另外少许改进。不再是将path(路径)和list(列表)创建为main()的本地变量,它们变成了类的成员,使它们的值能在对象“生存”期间方便地访问。事实上,main()现在只是对类进行测试的一种方式。大家可以看到,一旦列表创建完毕,类的构建器就会自动开始对列表进行排序。
这种排序不要求区分大小写,所以最终不会得到一组全部单词都以大写字母开头的列表,跟着是全部以小写字母开头的列表。然而,我们注意到在以相同字母开头的一组文件名中,大写字母是排在前面的——这对标准的排序来说仍是一种不合格的行为。Java 1.2已成功解决了这个问题。

10.4.2 检查与创建目录
File类并不仅仅是对现有目录路径、文件或者文件组的一个表示。亦可用一个File对象新建一个目录,甚至创建一个完整的目录路径——假如它尚不存在的话。亦可用它了解文件的属性(长度、上一次修改日期、读/写属性等),检查一个File对象到底代表一个文件还是一个目录,以及删除一个文件等等。下列程序完整展示了如何运用File类剩下的这些方法:


 java.io.*;

  MakeDirectories {
     String usage =
     +
     +
     +
     +
     +
    ;
     usage() {
    System.err.println(usage);
    System.exit(1);
  }
     fileData(File f) {
    System.out.println(
       + f.getAbsolutePath() +
       + f.canRead() +
       + f.canWrite() +
       + f.getName() +
       + f.getParent() +
       + f.getPath() +
       + f.length() +
       + f.lastModified());
    (f.isFile())
      System.out.println();
     (f.isDirectory())
      System.out.println();
  }
     main(String[] args) {
    (args.length < 1) usage();
    (args[0].equals()) {
      (args.length != 3) usage();
      File 
        old =  File(args[1]),
        rname =  File(args[2]);
      old.renameTo(rname);
      fileData(old);
      fileData(rname);
      ; 
    }
     count = 0;
     del = ;
    (args[0].equals()) {
      count++;
      del = ;
    }
    ( ; count < args.length; count++) {
      File f =  File(args[count]);
      (f.exists()) {
        System.out.println(f + );
        (del) {
          System.out.println( + f);
          f.delete();
        }
      } 
       { 
        (!del) {
          f.mkdirs();
          System.out.println( + f);
        }
      }
      fileData(f);
    }  
  }
} 

在fileData()中,可看到应用了各种文件调查方法来显示与文件或目录路径有关的信息。
main()应用的第一个方法是renameTo(),利用它可以重命名(或移动)一个文件至一个全新的路径(该路径由参数决定),它属于另一个File对象。这也适用于任何长度的目录。
若试验上述程序,就可发现自己能制作任意复杂程度的一个目录路径,因为mkdirs()会帮我们完成所有工作。在Java 1.0中,-d标志报告目录虽然已被删除,但它依然存在;但在Java 1.1中,目录会被实际删除。

10.5 IO流的典型应用
尽管库内存在大量IO流类,可通过多种不同的方式组合到一起,但实际上只有几种方式才会经常用到。然而,必须小心在意才能得到正确的组合。下面这个相当长的例子展示了典型IO配置的创建与使用,可在写自己的代码时将其作为一个参考使用。注意每个配置都以一个注释形式的编号起头,并提供了适当的解释信息。

 java.io.*;
 com.bruceeckel.tools.*;

  IOStreamDemo {
     main(String[] args) {
     {
      
      DataInputStream in =
         DataInputStream(
           BufferedInputStream(
             FileInputStream(args[0])));
      String s, s2 =  String();
      ((s = in.readLine())!= )
        s2 += s + ;
      in.close();

      
      StringBufferInputStream in2 =
           StringBufferInputStream(s2);
       c;
      ((c = in2.read()) != -1)
        System.out.print(()c);

      
       {
        DataInputStream in3 =
           DataInputStream(
             StringBufferInputStream(s2));
        ()
          System.out.print(()in3.readByte());
      } (EOFException e) {
        System.out.println(
          );
      }

      
       {
        LineNumberInputStream li =
           LineNumberInputStream(
             StringBufferInputStream(s2));
        DataInputStream in4 =
           DataInputStream(li);
        PrintStream out1 =
           PrintStream(
             BufferedOutputStream(
               FileOutputStream(
                )));
        ((s = in4.readLine()) !=  )
          out1.println(
             + li.getLineNumber() + s);
        out1.close(); 
      } (EOFException e) {
        System.out.println(
          );
      }

      
       {
        DataOutputStream out2 =
           DataOutputStream(
             BufferedOutputStream(
               FileOutputStream()));
        out2.writeBytes(
          );
        out2.writeDouble(3.14159);
        out2.close();
        DataInputStream in5 =
           DataInputStream(
             BufferedInputStream(
               FileInputStream()));
        System.out.println(in5.readLine());
        System.out.println(in5.readDouble());
      } (EOFException e) {
        System.out.println(
          );
      }

      
      RandomAccessFile rf =
         RandomAccessFile(, );
      ( i = 0; i < 10; i++)
        rf.writeDouble(i*1.414);
      rf.close();

      rf =
         RandomAccessFile(, );
      rf.seek(5*8);
      rf.writeDouble(47.0001);
      rf.close();

      rf =
         RandomAccessFile(, );
      ( i = 0; i < 10; i++)
        System.out.println(
           + i +  +
          rf.readDouble());
      rf.close();

      
      InFile in6 =  InFile(args[0]);
      String s3 =  String();
      System.out.println(
         +
        in6.readLine());
        in6.close();

      
      PrintFile out3 =  PrintFile();
      out3.print();
      out3.close();

      
      OutFile out4 =  OutFile();
      out4.writeBytes();
      out4.writeChars();
      out4.close();

    } (FileNotFoundException e) {
      System.out.println(
         + args[0]);
    } (IOException e) {
      System.out.println();
    }
  }
} 

10.5.1 输入流
当然,我们经常想做的一件事情是将格式化的输出打印到控制台,但那已在第5章创建的com.bruceeckel.tools中得到了简化。
第1到第4部分演示了输入流的创建与使用(尽管第4部分展示了将输出流作为一个测试工具的简单应用)。

1. 缓冲的输入文件
为打开一个文件以便输入,需要使用一个FileInputStream,同时将一个String或File对象作为文件名使用。为提高速度,最好先对文件进行缓冲处理,从而获得用于一个BufferedInputStream的构建器的结果句柄。为了以格式化的形式读取输入数据,我们将那个结果句柄赋给用于一个DataInputStream的构建器。DataInputStream是我们的最终(final)对象,并是我们进行读取操作的接口。
在这个例子中,只用到了readLine()方法,但理所当然任何DataInputStream方法都可以采用。一旦抵达文件末尾,readLine()就会返回一个null(空),以便中止并退出while循环。
“String s2”用于聚集完整的文件内容(包括必须添加的新行,因为readLine()去除了那些行)。随后,在本程序的后面部分中使用s2。最后,我们调用close(),用它关闭文件。从技术上说,会在运行finalize()时调用close()。而且我们希望一旦程序退出,就发生这种情况(无论是否进行垃圾收集)。然而,Java 1.0有一个非常突出的错误(Bug),造成这种情况不会发生。在Java 1.1中,必须明确调用System.runFinalizersOnExit(true),用它保证会为系统中的每个对象调用finalize()。然而,最安全的方法还是为文件明确调用close()。

2. 从内存输入
这一部分采用已经包含了完整文件内容的String s2,并用它创建一个StringBufferInputStream(字串缓冲输入流)——作为构建器的参数,要求使用一个String,而非一个StringBuffer)。随后,我们用read()依次读取每个字符,并将其发送至控制台。注意read()将下一个字节返回为int,所以必须将其造型为一个char,以便正确地打印。

3. 格式化内存输入
StringBufferInputStream的接口是有限的,所以通常需要将其封装到一个DataInputStream内,从而增强它的能力。然而,若选择用readByte()每次读出一个字符,那么所有值都是有效的,所以不可再用返回值来侦测何时结束输入。相反,可用available()方法判断有多少字符可用。下面这个例子展示了如何从文件中一次读出一个字符:


 java.io.*;

  TestEOF {
     main(String[] args) {
     {
      DataInputStream in = 
         DataInputStream(
          BufferedInputStream(
           FileInputStream()));
      (in.available() != 0)
        System.out.print(()in.readByte());
    }  (IOException e) {
      System.err.println();
    }
  }
} 

注意取决于当前从什么媒体读入,avaiable()的工作方式也是有所区别的。它在字面上意味着“可以不受阻塞读取的字节数量”。对一个文件来说,它意味着整个文件。但对一个不同种类的数据流来说,它却可能有不同的含义。因此在使用时应考虑周全。
为了在这样的情况下侦测输入的结束,也可以通过捕获一个违例来实现。然而,若真的用违例来控制数据流,却显得有些大材小用。

4. 行的编号与文件输出
这个例子展示了如何LineNumberInputStream来跟踪输入行的编号。在这里,不可简单地将所有构建器都组合起来,因为必须保持LineNumberInputStream的一个句柄(注意这并非一种继承环境,所以不能简单地将in4造型到一个LineNumberInputStream)。因此,li容纳了指向LineNumberInputStream的句柄,然后在它的基础上创建一个DataInputStream,以便读入数据。
这个例子也展示了如何将格式化数据写入一个文件。首先创建了一个FileOutputStream,用它同一个文件连接。考虑到效率方面的原因,它生成了一个BufferedOutputStream。这几乎肯定是我们一般的做法,但却必须明确地这样做。随后为了进行格式化,它转换成一个PrintStream。用这种方式创建的数据文件可作为一个原始的文本文件读取。
标志DataInputStream何时结束的一个方法是readLine()。一旦没有更多的字串可以读取,它就会返回null。每个行都会伴随自己的行号打印到文件里。该行号可通过li查询。
可看到用于out1的、一个明确指定的close()。若程序准备掉转头来,并再次读取相同的文件,这种做法就显得相当有用。然而,该程序直到结束也没有检查文件IODemo.txt。正如以前指出的那样,如果不为自己的所有输出文件调用close(),就可能发现缓冲区不会得到刷新,造成它们不完整。。

10.5.2 输出流
两类主要的输出流是按它们写入数据的方式划分的:一种按人的习惯写入,另一种为了以后由一个DataInputStream而写入。RandomAccessFile是独立的,尽管它的数据格式兼容于DataInputStream和DataOutputStream。

5. 保存与恢复数据
PrintStream能格式化数据,使其能按我们的习惯阅读。但为了输出数据,以便由另一个数据流恢复,则需用一个DataOutputStream写入数据,并用一个DataInputStream恢复(获取)数据。当然,这些数据流可以是任何东西,但这里采用的是一个文件,并进行了缓冲处理,以加快读写速度。
注意字串是用writeBytes()写入的,而非writeChars()。若使用后者,写入的就是16位Unicode字符。由于DataInputStream中没有补充的“readChars”方法,所以不得不用readChar()每次取出一个字符。所以对ASCII来说,更方便的做法是将字符作为字节写入,在后面跟随一个新行;然后再用readLine()将字符当作普通的ASCII行读回。
writeDouble()将double数字保存到数据流中,并用补充的readDouble()恢复它。但为了保证任何读方法能够正常工作,必须知道数据项在流中的准确位置,因为既有可能将保存的double数据作为一个简单的字节序列读入,也有可能作为char或其他格式读入。所以必须要么为文件中的数据采用固定的格式,要么将额外的信息保存到文件中,以便正确判断数据的存放位置。

6. 读写随机访问文件
正如早先指出的那样,RandomAccessFile与IO层次结构的剩余部分几乎是完全隔离的,尽管它也实现了DataInput和DataOutput接口。所以不可将其与InputStream及OutputStream子类的任何部分关联起来。尽管也许能将一个ByteArrayInputStream当作一个随机访问元素对待,但只能用RandomAccessFile打开一个文件。必须假定RandomAccessFile已得到了正确的缓冲,因为我们不能自行选择。
可以自行选择的是第二个构建器参数:可决定以“只读”(r)方式或“读写”(rw)方式打开一个RandomAccessFile文件。
使用RandomAccessFile的时候,类似于组合使用DataInputStream和DataOutputStream(因为它实现了等同的接口)。除此以外,还可看到程序中使用了seek(),以便在文件中到处移动,对某个值作出修改。

10.5.3 快捷文件处理
由于以前采用的一些典型形式都涉及到文件处理,所以大家也许会怀疑为什么要进行那么多的代码输入——这正是装饰器方案一个缺点。本部分将向大家展示如何创建和使用典型文件读取和写入配置的快捷版本。这些快捷版本均置入packagecom.bruceeckel.tools中(自第5章开始创建)。为了将每个类都添加到库内,只需将其置入适当的目录,并添加对应的package语句即可。

7. 快速文件输入
若想创建一个对象,用它从一个缓冲的DataInputStream中读取一个文件,可将这个过程封装到一个名为InFile的类内。如下所示:

 com.bruceeckel.tools;
 java.io.*;

  InFile  DataInputStream {
   InFile(String filename)
     FileNotFoundException {
    (
       BufferedInputStream(
         FileInputStream(filename)));
  }
   InFile(File file)
     FileNotFoundException {
    (file.getPath());
  }
} 

无论构建器的String版本还是File版本都包括在内,用于共同创建一个FileInputStream。
就象这个例子展示的那样,现在可以有效减少创建文件时由于重复强调造成的问题。

8. 快速输出格式化文件
亦可用同类型的方法创建一个PrintStream,令其写入一个缓冲文件。下面是对com.bruceeckel.tools的扩展:


 com.bruceeckel.tools;
 java.io.*;

  PrintFile  PrintStream {
   PrintFile(String filename)
     IOException {
    (
       BufferedOutputStream(
         FileOutputStream(filename)));
  }
   PrintFile(File file)
     IOException {
    (file.getPath());
  }
} 

注意构建器不可能捕获一个由基础类构建器“掷”出的违例。

9. 快速输出数据文件
最后,利用类似的快捷方式可创建一个缓冲输出文件,用它保存数据(与由人观看的数据格式相反):


 com.bruceeckel.tools;
 java.io.*;

  OutFile  DataOutputStream {
   OutFile(String filename)
     IOException {
    (
       BufferedOutputStream(
         FileOutputStream(filename)));
  }
   OutFile(File file)
     IOException {
    (file.getPath());
  }
} 

非常奇怪的是(也非常不幸),Java库的设计者居然没想到将这些便利措施直接作为他们的一部分标准提供。

10.5.4 从标准输入中读取数据
以Unix首先倡导的“标准输入”、“标准输出”以及“标准错误输出”概念为基础,Java提供了相应的System.in,System.out以及System.err。贯这一整本书,大家都会接触到如何用System.out进行标准输出,它已预封装成一个PrintStream对象。System.err同样是一个PrintStream,但System.in是一个原始的InputStream,未进行任何封装处理。这意味着尽管能直接使用System.out和System.err,但必须事先封装System.in,否则不能从中读取数据。
典型情况下,我们希望用readLine()每次读取一行输入信息,所以需要将System.in封装到一个DataInputStream中。这是Java 1.0进行行输入时采取的“老”办法。在本章稍后,大家还会看到Java 1.1的解决方案。下面是个简单的例子,作用是回应我们键入的每一行内容:

 java.io.*;

  Echo {
     main(String[] args) {
    DataInputStream in =
       DataInputStream(
         BufferedInputStream(System.in));
    String s;
     {
      ((s = in.readLine()).length() != 0)
        System.out.println(s);
      
    } (IOException e) {
      e.printStackTrace();
    }
  }
} 

之所以要使用try块,是由于readLine()可能“掷”出一个IOException。注意同其他大多数流一样,也应对System.in进行缓冲。
由于在每个程序中都要将System.in封装到一个DataInputStream内,所以显得有点不方便。但采用这种设计方案,可以获得最大的灵活性。

10.5.5 管道数据流
本章已简要介绍了PipedInputStream(管道输入流)和PipedOutputStream(管道输出流)。尽管描述不十分详细,但并不是说它们作用不大。然而,只有在掌握了多线程处理的概念后,才可真正体会它们的价值所在。原因很简单,因为管道化的数据流就是用于线程之间的通信。这方面的问题将在第14章用一个示例说明。

10.6 StreamTokenizer
尽管StreamTokenizer并不是从InputStream或OutputStream衍生的,但它只随同InputStream工作,所以十分恰当地包括在库的IO部分中。
StreamTokenizer类用于将任何InputStream分割为一系列“记号”(Token)。这些记号实际是一些断续的文本块,中间用我们选择的任何东西分隔。例如,我们的记号可以是单词,中间用空白(空格)以及标点符号分隔。
下面是一个简单的程序,用于计算各个单词在文本文件中重复出现的次数:


 java.io.*;
 java.util.*;
 c08.*; 

 Counter {
    i = 1;
   read() {  i; }
   increment() { i++; }
}

  SortedWordCount {
   FileInputStream file;
   StreamTokenizer st;
   Hashtable counts =  Hashtable();
  SortedWordCount(String filename)
     FileNotFoundException {
     {
      file =  FileInputStream(filename);
      st =  StreamTokenizer(file);
      st.ordinaryChar('.');
      st.ordinaryChar('-');
    } (FileNotFoundException e) {
      System.out.println(
         + filename);
       e;
    }
  }
   cleanup() {
     {
      file.close();
    } (IOException e) {
      System.out.println(
        );
    }
  }
   countWords() {
     {
      (st.nextToken() !=
        StreamTokenizer.TT_EOF) {
        String s;
        (st.ttype) {
           StreamTokenizer.TT_EOL:
            s =  String();
            ;
           StreamTokenizer.TT_NUMBER:
            s = Double.toString(st.nval);
            ;
           StreamTokenizer.TT_WORD:
            s = st.sval; 
            ;
          : 
            s = String.valueOf(()st.ttype);
        }
        (counts.containsKey(s))
          ((Counter)counts.get(s)).increment();
        
          counts.put(s,  Counter());
      }
    } (IOException e) {
      System.out.println(
        );
    }
  }
  Enumeration values() {
     counts.elements();
  }
  Enumeration keys() {  counts.keys(); }
  Counter getCounter(String s) {
     (Counter)counts.get(s);
  }
  Enumeration sortedKeys() {
    Enumeration e = counts.keys();
    StrSortVector sv =  StrSortVector();
    (e.hasMoreElements())
      sv.addElement((String)e.nextElement());
    
     sv.elements();
  }
     main(String[] args) {
     {
      SortedWordCount wc =
         SortedWordCount(args[0]);
      wc.countWords();
      Enumeration keys = wc.sortedKeys();
      (keys.hasMoreElements()) {
        String key = (String)keys.nextElement();
        System.out.println(key + 
                 + wc.getCounter(key).read());
      }
      wc.cleanup();
    } (Exception e) {
      e.printStackTrace();
    }
  }
} 

最好将结果按排序格式输出,但由于Java 1.0和Java 1.1都没有提供任何排序方法,所以必须由自己动手。这个目标可用一个StrSortVector方便地达成(创建于第8章,属于那一章创建的软件包的一部分。记住本书所有子目录的起始目录都必须位于类路径中,否则程序将不能正确地编译)。
为打开文件,使用了一个FileInputStream。而且为了将文件转换成单词,从FileInputStream中创建了一个StreamTokenizer。在StreamTokenizer中,存在一个默认的分隔符列表,我们可用一系列方法加入更多的分隔符。在这里,我们用ordinaryChar()指出“该字符没有特别重要的意义”,所以解析器不会把它当作自己创建的任何单词的一部分。例如,st.ordinaryChar('.')表示小数点不会成为解析出来的单词的一部分。在与Java配套提供的联机文档中,可以找到更多的相关信息。
在countWords()中,每次从数据流中取出一个记号,而ttype信息的作用是判断对每个记号采取什么操作——因为记号可能代表一个行尾、一个数字、一个字串或者一个字符。
找到一个记号后,会查询Hashtable counts,核实其中是否已经以“键”(Key)的形式包含了一个记号。若答案是肯定的,对应的Counter(计数器)对象就会增值,指出已找到该单词的另一个实例。若答案为否,则新建一个Counter——因为Counter构建器会将它的值初始化为1,正是我们计算单词数量时的要求。
SortedWordCount并不属于Hashtable(散列表)的一种类型,所以它不会继承。它执行的一种特定类型的操作,所以尽管keys()和values()方法都必须重新揭示出来,但仍不表示应使用那个继承,因为大量Hashtable方法在这里都是不适当的。除此以外,对于另一些方法来说(比如getCounter()——用于获得一个特定字串的计数器;又如sortedKeys()——用于产生一个枚举),它们最终都改变了SortedWordCount接口的形式。
在main()内,我们用SortedWordCount打开和计算文件中的单词数量——总共只用了两行代码。随后,我们为一个排好序的键(单词)列表提取出一个枚举。并用它获得每个键以及相关的Count(计数)。注意必须调用cleanup(),否则文件不能正常关闭。
采用了StreamTokenizer的第二个例子将在第17章提供。

10.6.1 StringTokenizer
尽管并不必要IO库的一部分,但StringTokenizer提供了与StreamTokenizer极相似的功能,所以在这里一并讲述。
StringTokenizer的作用是每次返回字串内的一个记号。这些记号是一些由制表站、空格以及新行分隔的连续字符。因此,字串“Where is my cat?”的记号分别是“Where”、“is”、“my”和“cat?”。与StreamTokenizer类似,我们可以指示StringTokenizer按照我们的愿望分割输入。但对于StringTokenizer,却需要向构建器传递另一个参数,即我们想使用的分隔字串。通常,如果想进行更复杂的操作,应使用StreamTokenizer。
可用nextToken()向StringTokenizer对象请求字串内的下一个记号。该方法要么返回一个记号,要么返回一个空字串(表示没有记号剩下)。
作为一个例子,下述程序将执行一个有限的句法分析,查询键短语序列,了解句子暗示的是快乐亦或悲伤的含义。


 java.util.*;

  AnalyzeSentence {
     main(String[] args) {
    analyze();
    analyze();
    analyze();
    analyze();
    analyze();
    analyze();
    analyze();
    analyze();
    analyze();
    analyze();
  }
   StringTokenizer st;
    analyze(String s) {
    prt( + s);
     sad = ;
    st =  StringTokenizer(s);
     (st.hasMoreTokens()) {
      String token = next();
      
      
      (!token.equals() &&
         !token.equals())
        ; 
      (token.equals()) {
        String tk2 = next();
        (!tk2.equals()) 
          ; 
         {
          String tk3 = next();
          (tk3.equals()) {
            sad = ;
            ; 
          }
           (tk3.equals()) {
            String tk4 = next();
            (tk4.equals())
              ; 
            (tk4.equals()) {
              sad = ;
              ;
            }
          }
        }
      }
      (token.equals()) {
        String tk2 = next();
        (!tk2.equals())
          ; 
        String tk3 = next();
        (tk3.equals())
          sad = ;
        ; 
      }
    }
    (sad) prt();
  }
   String next() {
    (st.hasMoreTokens()) {
      String s = st.nextToken();
      prt(s);
       s;
    } 
    
       ;
  }
    prt(String s) {
    System.out.println(s);
  }
} 

对于准备分析的每个字串,我们进入一个while循环,并将记号从那个字串中取出。请注意第一个if语句,假如记号既不是“I”,也不是“Are”,就会执行continue(返回循环起点,再一次开始)。这意味着除非发现一个“I”或者“Are”,才会真正得到记号。大家可能想用==代替equals()方法,但那样做会出现不正常的表现,因为==比较的是句柄值,而equals()比较的是内容。
analyze()方法剩余部分的逻辑是搜索“I am sad”(我很忧伤、“I am nothappy”(我不快乐)或者“Are you sad?”(你悲伤吗?)这样的句法格式。若没有break语句,这方面的代码甚至可能更加散乱。大家应注意对一个典型的解析器来说,通常都有这些记号的一个表格,并能在读取新记号的时候用一小段代码在表格内移动。
无论如何,只应将StringTokenizer看作StreamTokenizer一种简单而且特殊的简化形式。然而,如果有一个字串需要进行记号处理,而且StringTokenizer的功能实在有限,那么应该做的全部事情就是用StringBufferInputStream将其转换到一个数据流里,再用它创建一个功能更强大的StreamTokenizer。

10.7 Java 1.1的IO流
到这个时候,大家或许会陷入一种困境之中,怀疑是否存在IO流的另一种设计方案,并可能要求更大的代码量。还有人能提出一种更古怪的设计吗?事实上,Java 1.1对IO流库进行了一些重大的改进。看到Reader和Writer类时,大多数人的第一个印象(就象我一样)就是它们用来替换原来的InputStream和OutputStream类。但实情并非如此。尽管不建议使用原始数据流库的某些功能(如使用它们,会从编译器收到一条警告消息),但原来的数据流依然得到了保留,以便维持向后兼容,而且:
(1) 在老式层次结构里加入了新类,所以Sun公司明显不会放弃老式数据流。
(2) 在许多情况下,我们需要与新结构中的类联合使用老结构中的类。为达到这个目的,需要使用一些“桥”类:InputStreamReader将一个InputStream转换成Reader,OutputStreamWriter将一个OutputStream转换成Writer。
所以与原来的IO流库相比,经常都要对新IO流进行层次更多的封装。同样地,这也属于装饰器方案的一个缺点——需要为额外的灵活性付出代价。
之所以在Java 1.1里添加了Reader和Writer层次,最重要的原因便是国际化的需求。老式IO流层次结构只支持8位字节流,不能很好地控制16位Unicode字符。由于Unicode主要面向的是国际化支持(Java内含的char是16位的Unicode),所以添加了Reader和Writer层次,以提供对所有IO操作中的Unicode的支持。除此之外,新库也对速度进行了优化,可比旧库更快地运行。
与本书其他地方一样,我会试着提供对类的一个概述,但假定你会利用联机文档搞定所有的细节,比如方法的详尽列表等。

10.7.1 数据的发起与接收
Java 1.0的几乎所有IO流类都有对应的Java 1.1类,用于提供内建的Unicode管理。似乎最容易的事情就是“全部使用新类,再也不要用旧的”,但实际情况并没有这么简单。有些时候,由于受到库设计的一些限制,我们不得不使用Java 1.0的IO流类。特别要指出的是,在旧流库的基础上新加了java.util.zip库,它们依赖旧的流组件。所以最明智的做法是“尝试性”地使用Reader和Writer类。若代码不能通过编译,便知道必须换回老式库。
下面这张表格分旧库与新库分别总结了信息发起与接收之间的对应关系。

Sources & Sinks:
Java 1.0 class

Corresponding Java 1.1 class

InputStream

Reader
converter: InputStreamReader

OutputStream

Writer
converter: OutputStreamWriter

FileInputStream

FileReader

FileOutputStream

FileWriter

StringBufferInputStream

StringReader

(no corresponding class)

StringWriter

ByteArrayInputStream

CharArrayReader

ByteArrayOutputStream

CharArrayWriter

PipedInputStream

PipedReader

PipedOutputStream

PipedWriter


我们发现即使不完全一致,但旧库组件中的接口与新接口通常也是类似的。

10.7.2 修改数据流的行为
在Java 1.0中,数据流通过FilterInputStream和FilterOutputStream的“装饰器”(Decorator)子类适应特定的需求。Java 1.1的IO流沿用了这一思想,但没有继续采用所有装饰器都从相同“filter”(过滤器)基础类中衍生这一做法。若通过观察类的层次结构来理解它,这可能令人出现少许的困惑。
在下面这张表格中,对应关系比上一张表要粗糙一些。之所以会出现这个差别,是由类的组织造成的:尽管BufferedOutputStream是FilterOutputStream的一个子类,但是BufferedWriter并不是FilterWriter的子类(对后者来说,尽管它是一个抽象类,但没有自己的子类或者近似子类的东西,也没有一个“占位符”可用,所以不必费心地寻找)。然而,两个类的接口是非常相似的,而且不管在什么情况下,显然应该尽可能地使用新版本,而不应考虑旧版本(也就是说,除非在一些类中必须生成一个Stream,不可生成Reader或者Writer)。

Filters:
Java 1.0 class

Corresponding Java 1.1 class

FilterInputStream

FilterReader

FilterOutputStream

FilterWriter (abstract class with no subclasses)

BufferedInputStream

BufferedReader
(also has readLine( ))

BufferedOutputStream

BufferedWriter

DataInputStream

use DataInputStream
(Except when you need to use readLine( ), when you should use a BufferedReader)

PrintStream

PrintWriter

LineNumberInputStream

LineNumberReader

StreamTokenizer

StreamTokenizer
(use constructor that takes a Reader instead)

PushBackInputStream

PushBackReader


过滤器:Java 1.0类 对应的Java 1.1类

FilterInputStream FilterReader
FilterOutputStream FilterWriter(没有子类的抽象类)
BufferedInputStream BufferedReader(也有readLine())
BufferedOutputStream BufferedWriter
DataInputStream 使用DataInputStream(除非要使用readLine(),那时需要使用一个BufferedReader)
PrintStream PrintWriter
LineNumberInputStream LineNumberReader
StreamTokenizer StreamTokenizer(用构建器取代Reader)
PushBackInputStream PushBackReader

有一条规律是显然的:若想使用readLine(),就不要再用一个DataInputStream来实现(否则会在编译期得到一条出错消息),而应使用一个BufferedReader。但除这种情况以外,DataInputStream仍是Java 1.1 IO库的“首选”成员。
为了将向PrintWriter的过渡变得更加自然,它提供了能采用任何OutputStream对象的构建器。PrintWriter提供的格式化支持没有PrintStream那么多;但接口几乎是相同的。

10.7.3 未改变的类
显然,Java库的设计人员觉得以前的一些类毫无问题,所以没有对它们作任何修改,可象以前那样继续使用它们:

没有对应Java 1.1类的Java 1.0类

DataOutputStream
File
RandomAccessFile
SequenceInputStream

特别未加改动的是DataOutputStream,所以为了用一种可转移的格式保存和获取数据,必须沿用InputStream和OutputStream层次结构。

10.7.4 一个例子
为体验新类的效果,下面让我们看看如何修改IOStreamDemo.java示例的相应区域,以便使用Reader和Writer类:

 java.io.*;

  NewIODemo {
     main(String[] args) {
     {
      
      BufferedReader in =
         BufferedReader(
           FileReader(args[0]));
      String s, s2 =  String();
      ((s = in.readLine())!= )
        s2 += s + ;
      in.close();

      
      BufferedReader stdin =
         BufferedReader(
           InputStreamReader(System.in));      
      System.out.print();
      System.out.println(stdin.readLine());

      
      StringReader in2 =  StringReader(s2);
       c;
      ((c = in2.read()) != -1)
        System.out.print(()c);

      
       {
        DataInputStream in3 =
           DataInputStream(
            
             StringBufferInputStream(s2));
        ()
          System.out.print(()in3.readByte());
      } (EOFException e) {
        System.out.println();
      }

      
       {
        LineNumberReader li =
           LineNumberReader(
             StringReader(s2));
        BufferedReader in4 =
           BufferedReader(li);
        PrintWriter out1 =
           PrintWriter(
             BufferedWriter(
               FileWriter()));
        ((s = in4.readLine()) !=  )
          out1.println(
             + li.getLineNumber() + s);
        out1.close();
      } (EOFException e) {
        System.out.println();
      }

      
       {
        DataOutputStream out2 =
           DataOutputStream(
             BufferedOutputStream(
               FileOutputStream()));
        out2.writeDouble(3.14159);
        out2.writeBytes();
        out2.close();
        DataInputStream in5 =
           DataInputStream(
             BufferedInputStream(
               FileInputStream()));
        BufferedReader in5br =
           BufferedReader(
             InputStreamReader(in5));
        
        System.out.println(in5.readDouble());
        
        System.out.println(in5br.readLine());
      } (EOFException e) {
        System.out.println();
      }

      
      
      

    } (FileNotFoundException e) {
      System.out.println(
         + args[1]);
    } (IOException e) {
      System.out.println();
    }
  }
} 

大家一般看见的是转换过程非常直观,代码看起来也颇相似。但这些都不是重要的区别。最重要的是,由于随机访问文件已经改变,所以第6节未再重复。
第1节收缩了一点儿,因为假如要做的全部事情就是读取行输入,那么只需要将一个FileReader封装到BufferedReader之内即可。第1b节展示了封装System.in,以便读取控制台输入的新方法。这里的代码量增多了一些,因为System.in是一个DataInputStream,而且BufferedReader需要一个Reader参数,所以要用InputStreamReader来进行转换。
在2节,可以看到如果有一个字串,而且想从中读取数据,只需用一个StringReader替换StringBufferInputStream,剩下的代码是完全相同的。
第3节揭示了新IO流库设计中的一个错误。如果有一个字串,而且想从中读取数据,那么不能再以任何形式使用StringBufferInputStream。若编译一个涉及StringBufferInputStream的代码,会得到一条“反对”消息,告诉我们不要用它。此时最好换用一个StringReader。但是,假如要象第3节这样进行格式化的内存输入,就必须使用DataInputStream——没有什么“DataReader”可以代替它——而DataInputStream很不幸地要求用到一个InputStream参数。所以我们没有选择的余地,只好使用编译器不赞成的StringBufferInputStream类。编译器同样会发出反对信息,但我们对此束手无策(注释②)。
StringReader替换StringBufferInputStream,剩下的代码是完全相同的。

②:到你现在正式使用的时候,这个错误可能已经修正。

第4节明显是从老式数据流到新数据流的一个直接转换,没有需要特别指出的。在第5节中,我们被强迫使用所有的老式数据流,因为DataOutputStream和DataInputStream要求用到它们,而且没有可供替换的东西。然而,编译期间不会产生任何“反对”信息。若不赞成一种数据流,通常是由于它的构建器产生了一条反对消息,禁止我们使用整个类。但在DataInputStream的情况下,只有readLine()是不赞成使用的,因为我们最好为readLine()使用一个BufferedReader(但为其他所有格式化输入都使用一个DataInputStream)。
若比较第5节和IOStreamDemo.java中的那一小节,会注意到在这个版本中,数据是在文本之前写入的。那是由于Java 1.1本身存在一个错误,如下述代码所示:

 java.io.*;

  IOBug {
     main(String[] args) 
   Exception {
    DataOutputStream out =
       DataOutputStream(
         BufferedOutputStream(
           FileOutputStream()));
    out.writeDouble(3.14159);
    out.writeBytes();
    out.writeBytes();
    out.writeDouble(3.14159/2);
    out.close();

    DataInputStream in =
       DataInputStream(
         BufferedInputStream(
           FileInputStream()));
    BufferedReader inbr =
       BufferedReader(
         InputStreamReader(in));
    
    
    System.out.println(in.readDouble());
    
    System.out.println(inbr.readLine());
    System.out.println(inbr.readLine());
    
    
    System.out.println(in.readDouble());
  }
} 

看起来,我们在对一个writeBytes()的调用之后写入的任何东西都不是能够恢复的。这是一个十分有限的错误,希望在你读到本书的时候已获得改正。为检测是否改正,请运行上述程序。若没有得到一个违例,而且值都能正确打印出来,就表明已经改正。

10.7.5 重导向标准IO
Java 1.1在System类中添加了特殊的方法,允许我们重新定向标准输入、输出以及错误IO流。此时要用到下述简单的静态方法调用:
setIn(InputStream)
setOut(PrintStream)
setErr(PrintStream)
如果突然要在屏幕上生成大量输出,而且滚动的速度快于人们的阅读速度,输出的重定向就显得特别有用。在一个命令行程序中,如果想重复测试一个特定的用户输入序列,输入的重定向也显得特别有价值。下面这个简单的例子展示了这些方法的使用:


 java.io.*;

 Redirecting {
     main(String[] args) {
     {
      BufferedInputStream in = 
         BufferedInputStream(
           FileInputStream(
            ));
      
      PrintStream out =
         PrintStream(
           BufferedOutputStream(
             FileOutputStream()));
      System.setIn(in);
      System.setOut(out);
      System.setErr(out);

      BufferedReader br = 
         BufferedReader(
           InputStreamReader(System.in));
      String s;
      ((s = br.readLine()) != )
        System.out.println(s);
      out.close(); 
    } (IOException e) {
      e.printStackTrace();
    }
  }
} 

这个程序的作用是将标准输入同一个文件连接起来,并将标准输出和错误重定向至另一个文件。
这是不可避免会遇到“反对”消息的另一个例子。用-deprecation标志编译时得到的消息如下:

Note:The constructor java.io.PrintStream(java.io.OutputStream) has been deprecated.
注意:不推荐使用构建器java.io.PrintStream(java.io.OutputStream)。

然而,无论System.setOut()还是System.setErr()都要求用一个PrintStream作为参数使用,所以必须调用PrintStream构建器。所以大家可能会觉得奇怪,既然Java 1.1通过反对构建器而反对了整个PrintStream,为什么库的设计人员在添加这个反对的同时,依然为System添加了新方法,且指明要求用PrintStream,而不是用PrintWriter呢?毕竟,后者是一个崭新和首选的替换措施呀?这真令人费解。

10.8 压缩
Java 1.1也添加一个类,用以支持对压缩格式的数据流的读写。它们封装到现成的IO类中,以提供压缩功能。
此时Java 1.1的一个问题显得非常突出:它们不是从新的Reader和Writer类衍生出来的,而是属于InputStream和OutputStream层次结构的一部分。所以有时不得不混合使用两种类型的数据流(注意可用InputStreamReader和OutputStreamWriter在不同的类型间方便地进行转换)。

Java 1.1压缩类 功能

CheckedInputStream GetCheckSum()为任何InputStream产生校验和(不仅是解压)
CheckedOutputStream GetCheckSum()为任何OutputStream产生校验和(不仅是解压)
DeflaterOutputStream 用于压缩类的基础类
ZipOutputStream 一个DeflaterOutputStream,将数据压缩成Zip文件格式
GZIPOutputStream 一个DeflaterOutputStream,将数据压缩成GZIP文件格式
InflaterInputStream 用于解压类的基础类
ZipInputStream 一个DeflaterInputStream,解压用Zip文件格式保存的数据
GZIPInputStream 一个DeflaterInputStream,解压用GZIP文件格式保存的数据

尽管存在许多种压缩算法,但是Zip和GZIP可能最常用的。所以能够很方便地用多种现成的工具来读写这些格式的压缩数据。

10.8.1 用GZIP进行简单压缩
GZIP接口非常简单,所以如果只有单个数据流需要压缩(而不是一系列不同的数据),那么它就可能是最适当选择。下面是对单个文件进行压缩的例子:



 java.io.*;
 java.util.zip.*;

  GZIPcompress {
     main(String[] args) {
     {
      BufferedReader in =
         BufferedReader(
           FileReader(args[0]));
      BufferedOutputStream out =
         BufferedOutputStream(
           GZIPOutputStream(
             FileOutputStream()));
      System.out.println();
       c;
      ((c = in.read()) != -1)
        out.write(c);
      in.close();
      out.close();
      System.out.println();
      BufferedReader in2 =
         BufferedReader(
           InputStreamReader(
             GZIPInputStream(
               FileInputStream())));
      String s;
      ((s = in2.readLine()) != )
        System.out.println(s);
    } (Exception e) {
      e.printStackTrace();
    }
  }
} 

压缩类的用法非常直观——只需将输出流封装到一个GZIPOutputStream或者ZipOutputStream内,并将输入流封装到GZIPInputStream或者ZipInputStream内即可。剩余的全部操作就是标准的IO读写。然而,这是一个很典型的例子,我们不得不混合使用新旧IO流:数据的输入使用Reader类,而GZIPOutputStream的构建器只能接收一个OutputStream对象,不能接收Writer对象。

10.8.2 用Zip进行多文件保存
提供了Zip支持的Java 1.1库显得更加全面。利用它可以方便地保存多个文件。甚至有一个独立的类来简化对Zip文件的读操作。这个库采采用的是标准Zip格式,所以能与当前因特网上使用的大量压缩、解压工具很好地协作。下面这个例子采取了与前例相同的形式,但能根据我们需要控制任意数量的命令行参数。除此之外,它展示了如何用Checksum类来计算和校验文件的“校验和”(Checksum)。可选用两种类型的Checksum:Adler32(速度要快一些)和CRC32(慢一些,但更准确)。



 java.io.*;
 java.util.*;
 java.util.zip.*;

  ZipCompress {
     main(String[] args) {
     {
      FileOutputStream f =
         FileOutputStream();
      CheckedOutputStream csum =
         CheckedOutputStream(
          f,  Adler32());
      ZipOutputStream out =
         ZipOutputStream(
           BufferedOutputStream(csum));
      out.setComment();
      
      ( i = 0; i < args.length; i++) {
        System.out.println(
           + args[i]);
        BufferedReader in =
           BufferedReader(
             FileReader(args[i]));
        out.putNextEntry( ZipEntry(args[i]));
         c;
        ((c = in.read()) != -1)
          out.write(c);
        in.close();
      }
      out.close();
      
      
      System.out.println( +
        csum.getChecksum().getValue());
      
      System.out.println();
      FileInputStream fi =
          FileInputStream();
      CheckedInputStream csumi =
         CheckedInputStream(
          fi,  Adler32());
      ZipInputStream in2 =
         ZipInputStream(
           BufferedInputStream(csumi));
      ZipEntry ze;
      System.out.println( +
        csumi.getChecksum().getValue());
      ((ze = in2.getNextEntry()) != ) {
        System.out.println( + ze);
         x;
        ((x = in2.read()) != -1)
          System.out.write(x);
      }
      in2.close();
      
      
      ZipFile zf =  ZipFile();
      Enumeration e = zf.entries();
      (e.hasMoreElements()) {
        ZipEntry ze2 = (ZipEntry)e.nextElement();
        System.out.println( + ze2);
        
      }
    } (Exception e) {
      e.printStackTrace();
    }
  }
} 

对于要加入压缩档的每一个文件,都必须调用putNextEntry(),并将其传递给一个ZipEntry对象。ZipEntry对象包含了一个功能全面的接口,利用它可以获取和设置Zip文件内那个特定的Entry(入口)上能够接受的所有数据:名字、压缩后和压缩前的长度、日期、CRC校验和、额外字段的数据、注释、压缩方法以及它是否一个目录入口等等。然而,虽然Zip格式提供了设置密码的方法,但Java的Zip库没有提供这方面的支持。而且尽管CheckedInputStream和CheckedOutputStream同时提供了对Adler32和CRC32校验和的支持,但是ZipEntry只支持CRC的接口。这虽然属于基层Zip格式的限制,但却限制了我们使用速度更快的Adler32。
为解压文件,ZipInputStream提供了一个getNextEntry()方法,能在有的前提下返回下一个ZipEntry。作为一个更简洁的方法,可以用ZipFile对象读取文件。该对象有一个entries()方法,可以为ZipEntry返回一个Enumeration(枚举)。
为读取校验和,必须多少拥有对关联的Checksum对象的访问权限。在这里保留了指向CheckedOutputStream和CheckedInputStream对象的一个句柄。但是,也可以只占有指向Checksum对象的一个句柄。
Zip流中一个令人困惑的方法是setComment()。正如前面展示的那样,我们可在写一个文件时设置注释内容,但却没有办法取出ZipInputStream内的注释。看起来,似乎只能通过ZipEntry逐个入口地提供对注释的完全支持。
当然,使用GZIP或Zip库时并不仅仅限于文件——可以压缩任何东西,包括要通过网络连接发送的数据。

10.8.3 Java归档(jar)实用程序
Zip格式亦在Java 1.1的JAR(Java ARchive)文件格式中得到了采用。这种文件格式的作用是将一系列文件合并到单个压缩文件里,就象Zip那样。然而,同Java中其他任何东西一样,JAR文件是跨平台的,所以不必关心涉及具体平台的问题。除了可以包括声音和图像文件以外,也可以在其中包括类文件。
涉及因特网应用时,JAR文件显得特别有用。在JAR文件之前,Web浏览器必须重复多次请求Web服务器,以便下载完构成一个“程序片”(Applet)的所有文件。除此以外,每个文件都是未经压缩的。但在将所有这些文件合并到一个JAR文件里以后,只需向远程服务器发出一次请求即可。同时,由于采用了压缩技术,所以可在更短的时间里获得全部数据。另外,JAR文件里的每个入口(条目)都可以加上数字化签名(详情参考Java用户文档)。
一个JAR文件由一系列采用Zip压缩格式的文件构成,同时还有一张“详情单”,对所有这些文件进行了描述(可创建自己的详情单文件;否则,jar程序会为我们代劳)。在联机用户文档中,可以找到与JAR详情单更多的资料(详情单的英语是“Manifest”)。
jar实用程序已与Sun的JDK配套提供,可以按我们的选择自动压缩文件。请在命令行调用它:

jar [选项] 说明 [详情单] 输入文件

其中,“选项”用一系列字母表示(不必输入连字号或其他任何指示符)。如下所示:

c 创建新的或空的压缩档
t 列出目录表
x 解压所有文件
x file 解压指定文件
f 指出“我准备向你提供文件名”。若省略此参数,jar会假定它的输入来自标准输入;或者在它创建文件时,输出会进入标准输出内
m 指出第一个参数将是用户自建的详情表文件的名字
v 产生详细输出,对jar做的工作进行巨细无遗的描述
O 只保存文件;不压缩文件(用于创建一个JAR文件,以便我们将其置入自己的类路径中)
M 不自动生成详情表文件

在准备进入JAR文件的文件中,若包括了一个子目录,那个子目录会自动添加,其中包括它自己的所有子目录,以此类推。路径信息也会得到保留。
下面是调用jar的一些典型方法:

jar cf myJarFile.jar *.class
用于创建一个名为myJarFile.jar的JAR文件,其中包含了当前目录中的所有类文件,同时还有自动产生的详情表文件。

jar cmf myJarFile.jar myManifestFile.mf *.class
与前例类似,但添加了一个名为myManifestFile.mf的用户自建详情表文件。

jar tf myJarFile.jar
生成myJarFile.jar内所有文件的一个目录表。

jar tvf myJarFile.jar
添加“verbose”(详尽)标志,提供与myJarFile.jar中的文件有关的、更详细的资料。

jar cvf myApp.jar audio classes image
假定audio,classes和image是子目录,这样便将所有子目录合并到文件myApp.jar中。其中也包括了“verbose”标志,可在jar程序工作时反馈更详尽的信息。

如果用O选项创建了一个JAR文件,那个文件就可置入自己的类路径(CLASSPATH)中:
CLASSPATH="lib1.jar;lib2.jar;"
Java能在lib1.jar和lib2.jar中搜索目标类文件。

jar工具的功能没有zip工具那么丰富。例如,不能够添加或更新一个现成JAR文件中的文件,只能从头开始新建一个JAR文件。此外,不能将文件移入一个JAR文件,并在移动后将它们删除。然而,在一种平台上创建的JAR文件可在其他任何平台上由jar工具毫无阻碍地读出(这个问题有时会困扰zip工具)。
正如大家在第13章会看到的那样,我们也用JAR为Java Beans打包。

10.9 对象序列化
Java 1.1增添了一种有趣的特性,名为“对象序列化”(Object Serialization)。它面向那些实现了Serializable接口的对象,可将它们转换成一系列字节,并可在以后完全恢复回原来的样子。这一过程亦可通过网络进行。这意味着序列化机制能自动补偿操作系统间的差异。换句话说,可以先在Windows机器上创建一个对象,对其序列化,然后通过网络发给一台Unix机器,然后在那里准确无误地重新“装配”。不必关心数据在不同机器上如何表示,也不必关心字节的顺序或者其他任何细节。
就其本身来说,对象的序列化是非常有趣的,因为利用它可以实现“有限持久化”。请记住“持久化”意味着对象的“生存时间”并不取决于程序是否正在执行——它存在或“生存”于程序的每一次调用之间。通过序列化一个对象,将其写入磁盘,以后在程序重新调用时重新恢复那个对象,就能圆满实现一种“持久”效果。之所以称其为“有限”,是因为不能用某种“persistent”(持久)关键字简单地地定义一个对象,并让系统自动照看其他所有细节问题(尽管将来可能成为现实)。相反,必须在自己的程序中明确地序列化和组装对象。
语言里增加了对象序列化的概念后,可提供对两种主要特性的支持。Java 1.1的“远程方法调用”(RMI)使本来存在于其他机器的对象可以表现出好象就在本地机器上的行为。将消息发给远程对象时,需要通过对象序列化来传输参数和返回值。RMI将在第15章作具体讨论。
对象的序列化也是Java Beans必需的,后者由Java 1.1引入。使用一个Bean时,它的状态信息通常在设计期间配置好。程序启动以后,这种状态信息必须保存下来,以便程序启动以后恢复;具体工作由对象序列化完成。
对象的序列化处理非常简单,只需对象实现了Serializable接口即可(该接口仅是一个标记,没有方法)。在Java 1.1中,许多标准库类都发生了改变,以便能够序列化——其中包括用于基本数据类型的全部封装器、所有集合类以及其他许多东西。甚至Class对象也可以序列化(第11章讲述了具体实现过程)。
为序列化一个对象,首先要创建某些OutputStream对象,然后将其封装到ObjectOutputStream对象内。此时,只需调用writeObject()即可完成对象的序列化,并将其发送给OutputStream。相反的过程是将一个InputStream封装到ObjectInputStream内,然后调用readObject()。和往常一样,我们最后获得的是指向一个上溯造型Object的句柄,所以必须下溯造型,以便能够直接设置。
对象序列化特别“聪明”的一个地方是它不仅保存了对象的“全景图”,而且能追踪对象内包含的所有句柄并保存那些对象;接着又能对每个对象内包含的句柄进行追踪;以此类推。我们有时将这种情况称为“对象网”,单个对象可与之建立连接。而且它还包含了对象的句柄数组以及成员对象。若必须自行操纵一套对象序列化机制,那么在代码里追踪所有这些链接时可能会显得非常麻烦。在另一方面,由于Java对象的序列化似乎找不出什么缺点,所以请尽量不要自己动手,让它用优化的算法自动维护整个对象网。下面这个例子对序列化机制进行了测试。它建立了许多链接对象的一个“Worm”(蠕虫),每个对象都与Worm中的下一段链接,同时又与属于不同类(Data)的对象句柄数组链接:

 java.io.*;

 Data  Serializable {
    i;
  Data( x) { i = x; }
   String toString() {
     Integer.toString(i);
  }
}

  Worm  Serializable {
  
     r() {
     ()(Math.random() * 10);
  }
   Data[] d = {
     Data(r()),  Data(r()),  Data(r())
  };
   Worm next;
    c;
  
  Worm( i,  x) {
    System.out.println( + i);
    c = x;
    (--i > 0)
      next =  Worm(i, ()(x + 1));
  }
  Worm() {
    System.out.println();
  }
   String toString() {
    String s =  + c + ;
    ( i = 0; i < d.length; i++)
      s += d[i].toString();
    s += ;
    (next != )
      s += next.toString();
     s;
  }
     main(String[] args) {
    Worm w =  Worm(6, 'a');
    System.out.println( + w);
     {
      ObjectOutputStream out =
         ObjectOutputStream(
           FileOutputStream());
      out.writeObject();
      out.writeObject(w);
      out.close(); 
      ObjectInputStream in =
         ObjectInputStream(
           FileInputStream());
      String s = (String)in.readObject();
      Worm w2 = (Worm)in.readObject();
      System.out.println(s +  + w2);
    } (Exception e) {
      e.printStackTrace();
    }
     {
      ByteArrayOutputStream bout =
         ByteArrayOutputStream();
      ObjectOutputStream out =
         ObjectOutputStream(bout);
      out.writeObject();
      out.writeObject(w);
      out.flush();
      ObjectInputStream in =
         ObjectInputStream(
           ByteArrayInputStream(
            bout.toByteArray()));
      String s = (String)in.readObject();
      Worm w3 = (Worm)in.readObject();
      System.out.println(s +  + w3);
    } (Exception e) {
      e.printStackTrace();
    }
  }
} 

更有趣的是,Worm内的Data对象数组是用随机数字初始化的(这样便不用怀疑编译器保留了某种原始信息)。每个Worm段都用一个Char标记。这个Char是在重复生成链接的Worm列表时自动产生的。创建一个Worm时,需告诉构建器希望它有多长。为产生下一个句柄(next),它总是用减去1的长度来调用Worm构建器。最后一个next句柄则保持为null(空),表示已抵达Worm的尾部。
上面的所有操作都是为了加深事情的复杂程度,加大对象序列化的难度。然而,真正的序列化过程却是非常简单的。一旦从另外某个流里创建了ObjectOutputStream,writeObject()就会序列化对象。注意也可以为一个String调用writeObject()。亦可使用与DataOutputStream相同的方法写入所有基本数据类型(它们有相同的接口)。
有两个单独的try块看起来是类似的。第一个读写的是文件,而另一个读写的是一个ByteArray(字节数组)。可利用对任何DataInputStream或者DataOutputStream的序列化来读写特定的对象;正如在关于连网的那一章会讲到的那样,这些对象甚至包括网络。一次循环后的输出结果如下:
Worm constructor: 6
Worm constructor: 5
Worm constructor: 4
Worm constructor: 3
Worm constructor: 2
Worm constructor: 1
w = :a(262):b(100):c(396):d(480):e(316):f(398)
Worm storage, w2 = :a(262):b(100):c(396):d(480):e(316):f(398)
Worm storage, w3 = :a(262):b(100):c(396):d(480):e(316):f(398)

可以看出,装配回原状的对象确实包含了原来那个对象里包含的所有链接。
注意在对一个Serializable(可序列化)对象进行重新装配的过程中,不会调用任何构建器(甚至默认构建器)。整个对象都是通过从InputStream中取得数据恢复的。
作为Java 1.1特性的一种,我们注意到对象的序列化并不属于新的Reader和Writer层次结构的一部分,而是沿用老式的InputStream和OutputStream结构。所以在一些特殊的场合下,不得不混合使用两种类型的层次结构。

10.9.1 寻找类
读者或许会奇怪为什么需要一个对象从它的序列化状态中恢复。举个例子来说,假定我们序列化一个对象,并通过网络将其作为文件传送给另一台机器。此时,位于另一台机器的程序可以只用文件目录来重新构造这个对象吗?
回答这个问题的最好方法就是做一个实验。下面这个文件位于本章的子目录下:

 java.io.*;

  Alien  Serializable {
} 

用于创建和序列化一个Alien对象的文件位于相同的目录下:

 java.io.*;

  FreezeAlien {
     main(String[] args) 
       Exception {
    ObjectOutput out = 
       ObjectOutputStream(
         FileOutputStream());
    Alien zorcon =  Alien();
    out.writeObject(zorcon); 
  }
} 

该程序并不是捕获和控制违例,而是将违例简单、直接地传递到main()外部,这样便能在命令行报告它们。
程序编译并运行后,将结果产生的file.x复制到名为xfiles的子目录,代码如下:


 c10.xfiles;
 java.io.*;

  ThawAlien {
     main(String[] args) 
       Exception {
    ObjectInputStream in =
       ObjectInputStream(
         FileInputStream());
    Object mystery = in.readObject();
    System.out.println(
      mystery.getClass().toString());
  }
} 

该程序能打开文件,并成功读取mystery对象中的内容。然而,一旦尝试查找与对象有关的任何资料——这要求Alien的Class对象——Java虚拟机(JVM)便找不到Alien.class(除非它正好在类路径内,而本例理应相反)。这样就会得到一个名叫ClassNotFoundException的违例(同样地,若非能够校验Alien存在的证据,否则它等于消失)。
恢复了一个序列化的对象后,如果想对其做更多的事情,必须保证JVM能在本地类路径或者因特网的其他什么地方找到相关的.class文件。

10.9.2 序列化的控制
正如大家看到的那样,默认的序列化机制并不难操纵。然而,假若有特殊要求又该怎么办呢?我们可能有特殊的安全问题,不希望对象的某一部分序列化;或者某一个子对象完全不必序列化,因为对象恢复以后,那一部分需要重新创建。
此时,通过实现Externalizable接口,用它代替Serializable接口,便可控制序列化的具体过程。这个Externalizable接口扩展了Serializable,并增添了两个方法:writeExternal()和readExternal()。在序列化和重新装配的过程中,会自动调用这两个方法,以便我们执行一些特殊操作。
下面这个例子展示了Externalizable接口方法的简单应用。注意Blip1和Blip2几乎完全一致,除了极微小的差别(自己研究一下代码,看看是否能发现):

 java.io.*;
 java.util.*;

 Blip1  Externalizable {
   Blip1() {
    System.out.println();
  }
    writeExternal(ObjectOutput out)
       IOException {
    System.out.println();
  }
    readExternal(ObjectInput in)
      IOException, ClassNotFoundException {
    System.out.println();
  }
}

 Blip2  Externalizable {
  Blip2() {
    System.out.println();
  }
    writeExternal(ObjectOutput out)
       IOException {
    System.out.println();
  }
    readExternal(ObjectInput in)
      IOException, ClassNotFoundException {
    System.out.println();
  }
}

  Blips {
     main(String[] args) {
    System.out.println();
    Blip1 b1 =  Blip1();
    Blip2 b2 =  Blip2();
     {
      ObjectOutputStream o =
         ObjectOutputStream(
           FileOutputStream());
      System.out.println();
      o.writeObject(b1);
      o.writeObject(b2);
      o.close();
      
      ObjectInputStream in =
         ObjectInputStream(
           FileInputStream());
      System.out.println();
      b1 = (Blip1)in.readObject();
      


    } (Exception e) {
      e.printStackTrace();
    }
  }
} 

该程序输出如下:
Constructing objects:
Blip1 Constructor
Blip2 Constructor
Saving objects:
Blip1.writeExternal
Blip2.writeExternal
Recovering b1:
Blip1 Constructor
Blip1.readExternal

未恢复Blip2对象的原因是那样做会导致一个违例。你找出了Blip1和Blip2之间的区别吗?Blip1的构建器是“公共的”(public),Blip2的构建器则不然,这样便会在恢复时造成违例。试试将Blip2的构建器属性变成“public”,然后删除//!注释标记,看看是否能得到正确的结果。
恢复b1后,会调用Blip1默认构建器。这与恢复一个Serializable(可序列化)对象不同。在后者的情况下,对象完全以它保存下来的二进制位为基础恢复,不存在构建器调用。而对一个Externalizable对象,所有普通的默认构建行为都会发生(包括在字段定义时的初始化),而且会调用readExternal()。必须注意这一事实——特别注意所有默认的构建行为都会进行——否则很难在自己的Externalizable对象中产生正确的行为。
下面这个例子揭示了保存和恢复一个Externalizable对象必须做的全部事情:

 java.io.*;
 java.util.*;

 Blip3  Externalizable {
   i;
  String s; 
   Blip3() {
    System.out.println();
    
  }
   Blip3(String x,  a) {
    System.out.println();
    s = x;
    i = a;
    
    
  }
   String toString() {  s + i; }
    writeExternal(ObjectOutput out)
       IOException {
    System.out.println();
    
    out.writeObject(s); out.writeInt(i);
  }
    readExternal(ObjectInput in)
      IOException, ClassNotFoundException {
    System.out.println();
    
    s = (String)in.readObject(); 
    i =in.readInt();
  }
     main(String[] args) {
    System.out.println();
    Blip3 b3 =  Blip3(, 47);
    System.out.println(b3.toString());
     {
      ObjectOutputStream o =
         ObjectOutputStream(
           FileOutputStream());
      System.out.println();
      o.writeObject(b3);
      o.close();
      
      ObjectInputStream in =
         ObjectInputStream(
           FileInputStream());
      System.out.println();
      b3 = (Blip3)in.readObject();
      System.out.println(b3.toString());
    } (Exception e) {
      e.printStackTrace();
    }
  }
} 

其中,字段s和i只在第二个构建器中初始化,不关默认构建器的事。这意味着假如不在readExternal中初始化s和i,它们就会成为null(因为在对象创建的第一步中已将对象的存储空间清除为1)。若注释掉跟随于“You must do this”后面的两行代码,并运行程序,就会发现当对象恢复以后,s是null,而i是零。
若从一个Externalizable对象继承,通常需要调用writeExternal()和readExternal()的基础类版本,以便正确地保存和恢复基础类组件。
所以为了让一切正常运作起来,千万不可仅在writeExternal()方法执行期间写入对象的重要数据(没有默认的行为可用来为一个Externalizable对象写入所有成员对象)的,而是必须在readExternal()方法中也恢复那些数据。初次操作时可能会有些不习惯,因为Externalizable对象的默认构建行为使其看起来似乎正在进行某种存储与恢复操作。但实情并非如此。

1. transient(临时)关键字
控制序列化过程时,可能有一个特定的子对象不愿让Java的序列化机制自动保存与恢复。一般地,若那个子对象包含了不想序列化的敏感信息(如密码),就会面临这种情况。即使那种信息在对象中具有“private”(私有)属性,但一旦经序列化处理,人们就可以通过读取一个文件,或者拦截网络传输得到它。
为防止对象的敏感部分被序列化,一个办法是将自己的类实现为Externalizable,就象前面展示的那样。这样一来,没有任何东西可以自动序列化,只能在writeExternal()明确序列化那些需要的部分。
然而,若操作的是一个Serializable对象,所有序列化操作都会自动进行。为解决这个问题,可以用transient(临时)逐个字段地关闭序列化,它的意思是“不要麻烦你(指自动机制)保存或恢复它了——我会自己处理的”。
例如,假设一个Login对象包含了与一个特定的登录会话有关的信息。校验登录的合法性时,一般都想将数据保存下来,但不包括密码。为做到这一点,最简单的办法是实现Serializable,并将password字段设为transient。下面是具体的代码:

 java.io.*;
 java.util.*;

 Logon  Serializable {
   Date date =  Date();
   String username;
    String password;
  Logon(String name, String pwd) {
    username = name;
    password = pwd;
  }
   String toString() {
    String pwd =
      (password == ) ?  : password;
      +
       + username +
       + date.toString() +
       + pwd;
  }
     main(String[] args) {
    Logon a =  Logon(, );
    System.out.println(  + a);
     {
      ObjectOutputStream o =
         ObjectOutputStream(
           FileOutputStream());
      o.writeObject(a);
      o.close();
      
       seconds = 5;
       t = System.currentTimeMillis()
             + seconds * 1000;
      (System.currentTimeMillis() < t)
        ;
      
      ObjectInputStream in =
         ObjectInputStream(
           FileInputStream());
      System.out.println(
         +  Date());
      a = (Logon)in.readObject();
      System.out.println(  + a);
    } (Exception e) {
      e.printStackTrace();
    }
  }
} 

可以看到,其中的date和username字段保持原始状态(未设成transient),所以会自动序列化。然而,password被设为transient,所以不会自动保存到磁盘;另外,自动序列化机制也不会作恢复它的尝试。输出如下:
logon a = logon info:
   username: Hulk
   date: Sun Mar 23 18:25:53 PST 1997
   password: myLittlePony
Recovering object at Sun Mar 23 18:25:59 PST 1997
logon a = logon info:
   username: Hulk
   date: Sun Mar 23 18:25:53 PST 1997
   password: (n/a)

一旦对象恢复成原来的样子,password字段就会变成null。注意必须用toString()检查password是否为null,因为若用过载的“+”运算符来装配一个String对象,而且那个运算符遇到一个null句柄,就会造成一个名为NullPointerException的违例(新版Java可能会提供避免这个问题的代码)。
我们也发现date字段被保存到磁盘,并从磁盘恢复,没有重新生成。
由于Externalizable对象默认时不保存它的任何字段,所以transient关键字只能伴随Serializable使用。

2. Externalizable的替代方法
若不是特别在意要实现Externalizable接口,还有另一种方法可供选用。我们可以实现Serializable接口,并添加(注意是“添加”,而非“覆盖”或者“实现”)名为writeObject()和readObject()的方法。一旦对象被序列化或者重新装配,就会分别调用那两个方法。也就是说,只要提供了这两个方法,就会优先使用它们,而不考虑默认的序列化机制。
这些方法必须含有下列准确的签名:
  
  writeObject(ObjectOutputStream stream)
     IOException;

  
  readObject(ObjectInputStream stream)
     IOException, ClassNotFoundException

从设计的角度出发,情况变得有些扑朔迷离。首先,大家可能认为这些方法不属于基础类或者Serializable接口的一部分,它们应该在自己的接口中得到定义。但请注意它们被定义成“private”,这意味着它们只能由这个类的其他成员调用。然而,我们实际并不从这个类的其他成员中调用它们,而是由ObjectOutputStream和ObjectInputStream的writeObject()及readObject()方法来调用我们对象的writeObject()和readObject()方法(注意我在这里用了很大的抑制力来避免使用相同的方法名——因为怕混淆)。大家可能奇怪ObjectOutputStream和ObjectInputStream如何有权访问我们的类的private方法——只能认为这是序列化机制玩的一个把戏。
在任何情况下,接口中的定义的任何东西都会自动具有public属性,所以假若writeObject()和readObject()必须为private,那么它们不能成为接口(interface)的一部分。但由于我们准确地加上了签名,所以最终的效果实际与实现一个接口是相同的。
看起来似乎我们调用ObjectOutputStream.writeObject()的时候,我们传递给它的Serializable对象似乎会被检查是否实现了自己的writeObject()。若答案是肯定的是,便会跳过常规的序列化过程,并调用writeObject()。readObject()也会遇到同样的情况。
还存在另一个问题。在我们的writeObject()内部,可以调用defaultWriteObject(),从而决定采取默认的writeObject()行动。类似地,在readObject()内部,可以调用defaultReadObject()。下面这个简单的例子演示了如何对一个Serializable对象的存储与恢复进行控制:


 java.io.*;

  SerialCtl  Serializable {
  String a;
   String b;
   SerialCtl(String aa, String bb) {
    a =  + aa;
    b =  + bb;
  }
   String toString() {
     a +  + b;
  }
    
    writeObject(ObjectOutputStream stream)
       IOException {
    stream.defaultWriteObject();
    stream.writeObject(b);
  }
    
    readObject(ObjectInputStream stream)
       IOException, ClassNotFoundException {
    stream.defaultReadObject();
    b = (String)stream.readObject();
  }
     main(String[] args) {
    SerialCtl sc = 
       SerialCtl(, );
    System.out.println( + sc);
    ByteArrayOutputStream buf = 
       ByteArrayOutputStream();
     {
      ObjectOutputStream o =
         ObjectOutputStream(buf);
      o.writeObject(sc);
      
      ObjectInputStream in =
         ObjectInputStream(
           ByteArrayInputStream(
            buf.toByteArray()));
      SerialCtl sc2 = (SerialCtl)in.readObject();
      System.out.println( + sc2);
    } (Exception e) {
      e.printStackTrace();
    }
  }
} 

在这个例子中,一个String保持原始状态,其他设为transient(临时),以便证明非临时字段会被defaultWriteObject()方法自动保存,而transient字段必须在程序中明确保存和恢复。字段是在构建器内部初始化的,而不是在定义的时候,这证明了它们不会在重新装配的时候被某些自动化机制初始化。
若准备通过默认机制写入对象的非transient部分,那么必须调用defaultWriteObject(),令其作为writeObject()中的第一个操作;并调用defaultReadObject(),令其作为readObject()的第一个操作。这些都是不常见的调用方法。举个例子来说,当我们为一个ObjectOutputStream调用defaultWriteObject()的时候,而且没有为其传递参数,就需要采取这种操作,使其知道对象的句柄以及如何写入所有非transient的部分。这种做法非常不便。
transient对象的存储与恢复采用了我们更熟悉的代码。现在考虑一下会发生一些什么事情。在main()中会创建一个SerialCtl对象,随后会序列化到一个ObjectOutputStream里(注意这种情况下使用的是一个缓冲区,而非文件——与ObjectOutputStream完全一致)。正式的序列化操作是在下面这行代码里发生的:
o.writeObject(sc);
其中,writeObject()方法必须核查sc,判断它是否有自己的writeObject()方法(不是检查它的接口——它根本就没有,也不是检查类的类型,而是利用反射方法实际搜索方法)。若答案是肯定的,就使用那个方法。类似的情况也会在readObject()上发生。或许这是解决问题唯一实际的方法,但确实显得有些古怪。

3. 版本问题
有时候可能想改变一个可序列化的类的版本(比如原始类的对象可能保存在数据库中)。尽管这种做法得到了支持,但一般只应在非常特殊的情况下才用它。此外,它要求操作者对背后的原理有一个比较深的认识,而我们在这里还不想达到这种深度。JDK 1.1的HTML文档对这一主题进行了非常全面的论述(可从Sun公司下载,但可能也成了Java开发包联机文档的一部分)。

10.9.3 利用“持久性”
一个比较诱人的想法是用序列化技术保存程序的一些状态信息,从而将程序方便地恢复到以前的状态。但在具体实现以前,有些问题是必须解决的。如果两个对象都有指向第三个对象的句柄,该如何对这两个对象序列化呢?如果从两个对象序列化后的状态恢复它们,第三个对象的句柄只会出现在一个对象身上吗?如果将这两个对象序列化成独立的文件,然后在代码的不同部分重新装配它们,又会得到什么结果呢?
下面这个例子对上述问题进行了很好的说明:
 java.io.*;
 java.util.*;

 House  Serializable {}

 Animal  Serializable {
  String name;
  House preferredHouse;
  Animal(String nm, House h) { 
    name = nm; 
    preferredHouse = h;
  }
   String toString() {
     name +  + .toString() + 
       + preferredHouse + ;
  }
}

  MyWorld {
     main(String[] args) {
    House house =  House();
    Vector  animals =  Vector();
    animals.addElement(
       Animal(, house));
    animals.addElement(
       Animal(, house));
    animals.addElement(
       Animal(, house));
    System.out.println( + animals);

     {
      ByteArrayOutputStream buf1 = 
         ByteArrayOutputStream();
      ObjectOutputStream o1 =
         ObjectOutputStream(buf1);
      o1.writeObject(animals);
      o1.writeObject(animals); 
      
      ByteArrayOutputStream buf2 = 
         ByteArrayOutputStream();
      ObjectOutputStream o2 =
         ObjectOutputStream(buf2);
      o2.writeObject(animals);
      
      ObjectInputStream in1 =
         ObjectInputStream(
           ByteArrayInputStream(
            buf1.toByteArray()));
      ObjectInputStream in2 =
         ObjectInputStream(
           ByteArrayInputStream(
            buf2.toByteArray()));
      Vector animals1 = (Vector)in1.readObject();
      Vector animals2 = (Vector)in1.readObject();
      Vector animals3 = (Vector)in2.readObject();
      System.out.println( + animals1);
      System.out.println( + animals2);
      System.out.println( + animals3);
    } (Exception e) {
      e.printStackTrace();
    }
  }
} 

这里一件有趣的事情是也许是能针对一个字节数组应用对象的序列化,从而实现对任何Serializable(可序列化)对象的一个“全面复制”(全面复制意味着复制的是整个对象网,而不仅是基本对象和它的句柄)。复制问题将在第12章进行全面讲述。
Animal对象包含了类型为House的字段。在main()中,会创建这些Animal的一个Vector,并对其序列化两次,分别送入两个不同的数据流内。这些数据重新装配并打印出来后,可看到下面这样的结果(对象在每次运行时都会处在不同的内存位置,所以每次运行的结果有区别):
animals: [Bosco the dog[Animal@1cc76c], House@1cc769
, Ralph the hamster[Animal@1cc76d], House@1cc769
, Fronk the cat[Animal@1cc76e], House@1cc769
]
animals1: [Bosco the dog[Animal@1cca0c], House@1cca16
, Ralph the hamster[Animal@1cca17], House@1cca16
, Fronk the cat[Animal@1cca1b], House@1cca16
]
animals2: [Bosco the dog[Animal@1cca0c], House@1cca16
, Ralph the hamster[Animal@1cca17], House@1cca16
, Fronk the cat[Animal@1cca1b], House@1cca16
]
animals3: [Bosco the dog[Animal@1cca52], House@1cca5c
, Ralph the hamster[Animal@1cca5d], House@1cca5c
, Fronk the cat[Animal@1cca61], House@1cca5c
]

当然,我们希望装配好的对象有与原来不同的地址。但注意在animals1和animals2中出现了相同的地址,其中包括共享的、对House对象的引用。在另一方面,当animals3恢复以后,系统没有办法知道另一个流内的对象是第一个流内对象的化身,所以会产生一个完全不同的对象网。
只要将所有东西都序列化到单独一个数据流里,就能恢复获得与以前写入时完全一样的对象网,不会不慎造成对象的重复。当然,在写第一个和最后一个对象的时间之间,可改变对象的状态,但那必须由我们明确采取操作——序列化时,对象会采用它们当时的任何状态(包括它们与其他对象的连接关系)写入。
若想保存系统状态,最安全的做法是当作一种“微观”操作序列化。如果序列化了某些东西,再去做其他一些工作,再来序列化更多的东西,以此类推,那么最终将无法安全地保存系统状态。相反,应将构成系统状态的所有对象都置入单个集合内,并在一次操作里完成那个集合的写入。这样一来,同样只需一次方法调用,即可成功恢复之。
下面这个例子是一套假想的计算机辅助设计(CAD)系统,对这一方法进行了很好的演示。此外,它还为我们引入了static字段的问题——如留意联机文档,就会发现Class是“Serializable”(可序列化)的,所以只需简单地序列化Class对象,就能实现static字段的保存。这无论如何都是一种明智的做法。


 java.io.*;
 java.util.*;

  Shape  Serializable {
      
    RED = 1, BLUE = 2, GREEN = 3;
    xPos, yPos, dimension;
    Random r =  Random();
     counter = 0;
     setColor( newColor);
     getColor();
   Shape( xVal,  yVal,  dim) {
    xPos = xVal;
    yPos = yVal;
    dimension = dim;
  }
   String toString() {
     getClass().toString() + 
       + getColor() +
       + xPos +
       + yPos +
       + dimension + ;
  }
    Shape randomFactory() {
     xVal = r.nextInt() % 100;
     yVal = r.nextInt() % 100;
     dim = r.nextInt() % 100;
    (counter++ % 3) {
      : 
       0:   Circle(xVal, yVal, dim);
       1:   Square(xVal, yVal, dim);
       2:   Line(xVal, yVal, dim);
    }
  }
}

 Circle  Shape {
     color = RED;
   Circle( xVal,  yVal,  dim) {
    (xVal, yVal, dim);
  }
    setColor( newColor) { 
    color = newColor;
  }
    getColor() { 
     color;
  }
}

 Square  Shape {
     color;
   Square( xVal,  yVal,  dim) {
    (xVal, yVal, dim);
    color = RED;
  }
    setColor( newColor) { 
    color = newColor;
  }
    getColor() { 
     color;
  }
}

 Line  Shape {
     color = RED;
     
  serializeStaticState(ObjectOutputStream os)
       IOException {
    os.writeInt(color);
  }
     
  deserializeStaticState(ObjectInputStream os)
       IOException {
    color = os.readInt();
  }
   Line( xVal,  yVal,  dim) {
    (xVal, yVal, dim);
  }
    setColor( newColor) { 
    color = newColor;
  }
    getColor() { 
     color;
  }
}

  CADState {
     main(String[] args) 
       Exception {
    Vector shapeTypes, shapes;
    (args.length == 0) {
      shapeTypes =  Vector();
      shapes =  Vector();
      
      shapeTypes.addElement(Circle.);
      shapeTypes.addElement(Square.);
      shapeTypes.addElement(Line.);
      
      ( i = 0; i < 10; i++)
        shapes.addElement(Shape.randomFactory());
      
      ( i = 0; i < 10; i++)
        ((Shape)shapes.elementAt(i))
          .setColor(Shape.GREEN);
      
      ObjectOutputStream out =
         ObjectOutputStream(
           FileOutputStream());
      out.writeObject(shapeTypes);
      Line.serializeStaticState(out);
      out.writeObject(shapes);
    }  { 
      ObjectInputStream in =
         ObjectInputStream(
           FileInputStream(args[0]));
      
      shapeTypes = (Vector)in.readObject();
      Line.deserializeStaticState(in);
      shapes = (Vector)in.readObject();
    }
    
    System.out.println(shapes);
  }
} 

Shape(几何形状)类“实现了可序列化”(implements Serializable),所以从Shape继承的任何东西也都会自动“可序列化”。每个Shape都包含了数据,而且每个衍生的Shape类都包含了一个特殊的static字段,用于决定所有那些类型的Shape的颜色(如将一个static字段置入基础类,结果只会产生一个字段,因为static字段未在衍生类中复制)。可对基础类中的方法进行覆盖处理,以便为不同的类型设置颜色(static方法不会动态绑定,所以这些都是普通的方法)。每次调用randomFactory()方法时,它都会创建一个不同的Shape(Shape值采用随机值)。
Circle(圆)和Square(矩形)属于对Shape的直接扩展;唯一的差别是Circle在定义时会初始化颜色,而Square在构建器中初始化。Line(直线)的问题将留到以后讨论。
在main()中,一个Vector用于容纳Class对象,而另一个用于容纳形状。若不提供相应的命令行参数,就会创建shapeTypes Vector,并添加Class对象。然后创建shapes Vector,并添加Shape对象。接下来,所有static color值都会设成GREEN,而且所有东西都会序列化到文件CADState.out。
若提供了一个命令行参数(假设CADState.out),便会打开那个文件,并用它恢复程序的状态。无论在哪种情况下,结果产生的Shape的Vector都会打印出来。下面列出它某一次运行的结果:
>java CADState
[ Circle color[3] xPos[-51] yPos[-99] dim[38]
,  Square color[3] xPos[2] yPos[61] dim[-46]
,  Line color[3] xPos[51] yPos[73] dim[64]
,  Circle color[3] xPos[-70] yPos[1] dim[16]
,  Square color[3] xPos[3] yPos[94] dim[-36]
,  Line color[3] xPos[-84] yPos[-21] dim[-35]
,  Circle color[3] xPos[-75] yPos[-43] dim[22]
,  Square color[3] xPos[81] yPos[30] dim[-45]
,  Line color[3] xPos[-29] yPos[92] dim[17]
,  Circle color[3] xPos[17] yPos[90] dim[-76]
]

>java CADState CADState.out
[ Circle color[1] xPos[-51] yPos[-99] dim[38]
,  Square color[0] xPos[2] yPos[61] dim[-46]
,  Line color[3] xPos[51] yPos[73] dim[64]
,  Circle color[1] xPos[-70] yPos[1] dim[16]
,  Square color[0] xPos[3] yPos[94] dim[-36]
,  Line color[3] xPos[-84] yPos[-21] dim[-35]
,  Circle color[1] xPos[-75] yPos[-43] dim[22]
,  Square color[0] xPos[81] yPos[30] dim[-45]
,  Line color[3] xPos[-29] yPos[92] dim[17]
,  Circle color[1] xPos[17] yPos[90] dim[-76]
]

从中可以看出,xPos,yPos以及dim的值都已成功保存和恢复出来。但在获取static信息时却出现了问题。所有“3”都已进入,但没有正常地出来。Circle有一个1值(定义为RED),而Square有一个0值(记住,它们是在构建器里初始化的)。看上去似乎static根本没有得到初始化!实情正是如此——尽管类Class是“可以序列化的”,但却不能按我们希望的工作。所以假如想序列化static值,必须亲自动手。
这正是Line中的serializeStaticState()和deserializeStaticState()两个static方法的用途。可以看到,这两个方法都是作为存储和恢复进程的一部分明确调用的(注意写入序列化文件和从中读回的顺序不能改变)。所以为了使CADState.java正确运行起来,必须采用下述三种方法之一:
(1) 为几何形状添加一个serializeStaticState()和deserializeStaticState()。
(2) 删除Vector shapeTypes以及与之有关的所有代码
(3) 在几何形状内添加对新序列化和撤消序列化静态方法的调用
要注意的另一个问题是安全,因为序列化处理也会将private数据保存下来。若有需要保密的字段,应将其标记成transient。但在这之后,必须设计一种安全的信息保存方法。这样一来,一旦需要恢复,就可以重设那些private变量。

10.10 总结
Java IO流库能满足我们的许多基本要求:可以通过控制台、文件、内存块甚至因特网(参见第15章)进行读写。可以创建新的输入和输出对象类型(通过从InputStream和OutputStream继承)。向一个本来预期为收到字串的方法传递一个对象时,由于Java已限制了“自动类型转换”,所以会自动调用toString()方法。而我们可以重新定义这个toString(),扩展一个数据流能接纳的对象种类。
在IO数据流库的联机文档和设计过程中,仍有些问题没有解决。比如当我们打开一个文件以便输出时,完全可以指定一旦有人试图覆盖该文件就“掷”出一个违例——有的编程系统允许我们自行指定想打开一个输出文件,但唯一的前提是它尚不存在。但在Java中,似乎必须用一个File对象来判断某个文件是否存在,因为假如将其作为FileOutputStream或者FileWriter打开,那么肯定会被覆盖。若同时指定文件和目录路径,File类设计上的一个缺陷就会暴露出来,因为它会说“不要试图在单个类里做太多的事情”!
IO流库易使我们混淆一些概念。它确实能做许多事情,而且也可以移植。但假如假如事先没有吃透装饰器方案的概念,那么所有的设计都多少带有一点盲目性质。所以不管学它还是教它,都要特别花一些功夫才行。而且它并不完整:没有提供对输出格式化的支持,而其他几乎所有语言的IO包都提供了这方面的支持(这一点没有在Java 1.1里得以纠正,它完全错失了改变库设计方案的机会,反而增添了更特殊的一些情况,使复杂程度进一步提高)。Java 1.1转到那些尚未替换的IO库,而不是增加新库。而且库的设计人员似乎没有很好地指出哪些特性是不赞成的,哪些是首选的,造成库设计中经常都会出现一些令人恼火的反对消息。
然而,一旦掌握了装饰器方案,并开始在一些较为灵活的环境使用库,就会认识到这种设计的好处。到那个时候,为此多付出的代码行应该不至于使你觉得太生气。

10.11 练习
(1) 打开一个文本文件,每次读取一行内容。将每行作为一个String读入,并将那个String对象置入一个Vector里。按相反的顺序打印出Vector中的所有行。
(2) 修改练习1,使读取那个文件的名字作为一个命令行参数提供。
(3) 修改练习2,又打开一个文本文件,以便将文字写入其中。将Vector中的行随同行号一起写入文件。
(4) 修改练习2,强迫Vector中的所有行都变成大写形式,将结果发给System.out。
(5) 修改练习2,在文件中查找指定的单词。打印出包含了欲找单词的所有文本行。
(6) 在Blips.java中复制文件,将其重命名为BlipCheck.java。然后将类Blip2重命名为BlipCheck(在进程中将其标记为public)。删除文件中的//!记号,并执行程序。接下来,将BlipCheck的默认构建器变成注释信息。运行它,并解释为什么仍然能够工作。
(7) 在Blip3.java中,将接在“You must do this:”字样后的两行变成注释,然后运行程序。解释得到的结果为什么会与执行了那两行代码不同。
(8) 转换SortedWordCount.java程序,以便使用Java 1.1 IO流。
(9) 根据本章正文的说明修改程序CADState.java。
(10) 在第7章(中间部分)找到GreenhouseControls.java示例,它应该由三个文件构成。在GreenhouseControls.java中,Restart()内部类有一个硬编码的事件集。请修改这个程序,使其能从一个文本文件里动态读取事件以及它们的相关时间。

 

英文版主页 | 中文版主页 | 详细目录 | 关于译者

 

java编程思想 第四版 第六章 个人练习

java编程思想 第四版 第六章 答案,中文版 练习1:(1)在某个包中创建一个类,在这个类所处的包的外部创建该类的一个实例。 练习2:(1)将本节中的代码片段改写为完整的程序,并校验实际所发生的冲突...
  • zhaoqingkaitt
  • zhaoqingkaitt
  • 2014年11月04日 16:50
  • 2836

Java编程思想第四版 第三章个人练习

第三章 练习9
  • zhaoqingkaitt
  • zhaoqingkaitt
  • 2014年11月02日 17:25
  • 1735

重读《Java编程思想(第四版)》(10-17章、18章部分)

这些章节读起来就比前面的章节吃力多了,应该不能算重读了(因为大二第一遍读的时候这些章节就只是草草看的),但记录一下关键点。有些地方的记录可能过于粗略,因为只可意会,不可言传。   1.使用“类名.t...
  • King_Like_Coding
  • King_Like_Coding
  • 2016年04月22日 20:28
  • 2267

java编程思想 第四版 第七章读书笔记

java编程思想读书笔记
  • abc709272013
  • abc709272013
  • 2016年09月19日 21:30
  • 361

Java编程思想第四版 *第五章 个人练习

练习3:(1)创建一个带默认构造器(即无参构造器)的类,在构造器中打印一条消息。为这个类创建一个对象 练习4:(1)为前一个练习中的类添加一个重载构造器,令其接受一个字符参数,并在构造器中把你自己的信...
  • zhaoqingkaitt
  • zhaoqingkaitt
  • 2014年11月03日 10:01
  • 4166

Java编程思想第四版第八章学习——多态

在面向对象的程序设计语言中,多态是继数据抽象和继承之后的第三种基本特征。使用多态可以改善代码的组织结构和可读性,重要的是可以创建可扩展的程序。 所谓多态,就是把不同的子类对象都当做父类来看,可以屏...
  • Muc_hui
  • Muc_hui
  • 2016年05月19日 16:31
  • 294

Java编程思想第四版 第四章个人练习

Java编程思想第四版 第四章个人练习
  • zhaoqingkaitt
  • zhaoqingkaitt
  • 2014年11月03日 15:21
  • 2367

《Java编程思想第四版》笔记---17章 容器

java集合容器框架图 集合主要分3大类: List特点:元素有放入顺序,元素可重复。 Set特点:元素无放入顺序,元素不可重复(注意:元素虽然无放入顺序,但是元素在set中的位置是有该...
  • u012861467
  • u012861467
  • 2016年09月16日 11:30
  • 537

《Java编程思想第四版》笔记---18章(1) I/O 流基本概念

数据流的基本概念         数据流是一串连续不断的数据的集合,就象水管里的水流,在水管的一端一点一点地供水,而在水管的另一端看到的是一股连续不断的水流。数据写入程序可以是一段、一段地向数据...
  • u012861467
  • u012861467
  • 2016年09月19日 22:54
  • 276

Java编程思想第四版读书笔记——第五章 初始化与清理

Java编程思想第四版第五章读书笔记——初始化与清理
  • severusyue
  • severusyue
  • 2015年09月21日 21:17
  • 568
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java编程思想(第四版)_第10章 Java IO系统
举报原因:
原因补充:

(最多只允许输入30个字)