Java编程思想第4版[中文版](PDF格式)-第54部分

快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部! 如果本书没有阅读完，想下次继续接着阅读，可使用上方 "收藏到我的浏览器" 功能 和 "加入书签" 功能！




…………………………………………………………Page　294……………………………………………………………

　　　　　　〃n　getPath：　〃　＋　f。getPath（）　＋　　

　　　　　　〃n　length：　〃　＋　f。length（）　＋　　

　　　　　　〃n　lastModified：　〃　＋　f。lastModified（））；　　

　　　　if（f。isFile（））　　

　　　　　　System。out。println（〃it's　a　file〃）；　　

　　　　else　if（f。isDirectory（））　　

　　　　　　System。out。println（〃it's　a　directory〃）；　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　if（args。length　《　1）　usage（）；　　

　　　　if（args＇0＇。equals（〃…r〃））　｛　　

　　　　　　if（args。length　！=　3）　usage（）；　　

　　　　　　File　　　

　　　　　　　　old　=　new　File（args＇1＇）；　　

　　　　　　　　rname　=　new　File（args＇2＇）；　　

　　　　　　old。renameTo（rname）；　　

　　　　　　fileData（old）；　　

　　　　　　fileData（rname）；　　

　　　　　　return；　//　Exit　main　　

　　　　｝　　

　　　　int　count　=　0；　　

　　　　boolean　del　=　false；　　

　　　　if（args＇0＇。equals（〃…d〃））　｛　　

　　　　　　count＋＋；　　

　　　　　　del　=　true；　　

　　　　｝　　

　　　　for（　；　count　《　args。length；　count＋＋）　｛　　

　　　　　　File　f　=　new　File（args＇count＇）；　　

　　　　　　if（f。exists（））　｛　　

　　　　　　　　System。out。println（f　＋　〃　exists〃）；　　　

　　　　　　　　if（del）　｛　　

　　　　　　　　　　System。out。println（〃deleting。。。〃　＋　f）；　　

　　　　　　　　　　f。delete（）；　　

　　　　　　　　｝　　

　　　　　　｝　　　

　　　　　　else　｛　//　Doesn't　exist　　

　　　　　　　　if（！del）　｛　　

　　　　　　　　　　f。mkdirs（）；　　

　　　　　　　　　　System。out。println（〃created　〃　＋　f）；　　

　　　　　　　　｝　　

　　　　　　｝　　

　　　　　　fileData（f）；　　

　　　　｝　　　　

　　｝　　

｝　///：~　　

　　

在　fileData（）中，可看到应用了各种文件调查方法来显示与文件或目录路径有关的信息。　　

main（）应用的第一个方法是　renameTo（），利用它可以重命名（或移动）一个文件至一个全新的路径（该路径　

由参数决定），它属于另一个File　对象。这也适用于任何长度的目录。　　

若试验上述程序，就可发现自己能制作任意复杂程度的一个目录路径，因为mkdirs（）　会帮我们完成所有工　

作。在　Java　1。0　中，…d　标志报告目录虽然已被删除，但它依然存在；但在　Java　1。1　中，目录会被实际删　

除。　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　293　


…………………………………………………………Page　295……………………………………………………………

10。5　IO　流的典型应用　　



尽管库内存在大量　IO　流类，可通过多种不同的方式组合到一起，但实际上只有几种方式才会经常用到。然　

而，必须小心在意才能得到正确的组合。下面这个相当长的例子展示了典型　IO　配置的创建与使用，可在写自　

己的代码时将其作为一个参考使用。注意每个配置都以一个注释形式的编号起头，并提供了适当的解释信　

息。　　

　　

//：　IOStreamDemo。java　　

//　Typical　IO　Stream　Configurations　　

import　java。io。*；　　

import　。bruceeckel。tools。*；　　

　　

public　class　IOStreamDemo　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　try　｛　　

　　　　　　//　1。　Buffered　input　file　　

　　　　　　DataInputStream　in　=　　

　　　　　　　　new　DataInputStream（　　

　　　　　　　　　　new　BufferedInputStream（　　

　　　　　　　　　　　　new　FileInputStream（args＇0＇）））；　　

　　　　　　String　s；　s2　=　new　String（）；　　

　　　　　　while（（s　=　in。readLine（））！=　null）　　

　　　　　　　　s2　＋=　s　＋　〃n〃；　　

　　　　　　in。close（）；　　

　　

　　　　　　//　2。　Input　from　memory　　

　　　　　　StringBufferInputStream　in2　=　　

　　　　　　　　　　new　StringBufferInputStream（s2）；　　

　　　　　　int　c；　　

　　　　　　while（（c　=　in2。read（））　！=　…1）　　

　　　　　　　　System。out。print（（char）c）；　　

　　

　　　　　　//　3。　Formatted　memory　input　　

　　　　　　try　｛　　

　　　　　　　　DataInputStream　in3　=　　

　　　　　　　　　　new　DataInputStream（　　

　　　　　　　　　　　　new　StringBufferInputStream（s2））；　　

　　　　　　　　while（true）　　

　　　　　　　　　　System。out。print（（char）in3。readByte（））；　　

　　　　　　｝　catch（EOFException　e）　｛　　

　　　　　　　　System。out。println（　　

　　　　　　　　　　〃End　of　stream　encountered〃）；　　

　　　　　　｝　　

　　

　　　　　　//　4。　Line　numbering　&　file　output　　

　　　　　　try　｛　　

　　　　　　　　LineNumberInputStream　li　=　　

　　　　　　　　　　new　LineNumberInputStream（　　

　　　　　　　　　　　　new　StringBufferInputStream（s2））；　　

　　　　　　　　DataInputStream　in4　=　　

　　　　　　　　　　new　DataInputStream（li）；　　

　　　　　　　　PrintStream　out1　=　　

　　　　　　　　　　new　PrintStream（　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　294　


…………………………………………………………Page　296……………………………………………………………

　　　　　　　　　　　　new　BufferedOutputStream（　　

　　　　　　　　　　　　　　new　FileOutputStream（　　

　　　　　　　　　　　　　　　　〃IODemo。out〃）））；　　

　　　　　　　　while（（s　=　in4。readLine（））　！=　null　）　　

　　　　　　　　　　out1。println（　　

　　　　　　　　　　　　〃Line　〃　＋　li。getLineNumber（）　＋　s）；　　

　　　　　　　　out1。close（）；　//　finalize（）　not　reliable！　　

　　　　　　｝　catch（EOFException　e）　｛　　

　　　　　　　　System。out。println（　　

　　　　　　　　　　〃End　of　stream　encountered〃）；　　

　　　　　　｝　　

　　

　　　　　　//　5。　Storing　&　recovering　data　　

　　　　　　try　｛　　

　　　　　　　　DataOutputStream　out2　=　　

　　　　　　　　　　new　DataOutputStream（　　

　　　　　　　　　　　　new　BufferedOutputStream（　　

　　　　　　　　　　　　　　new　FileOutputStream（〃Data。txt〃）））；　　

　　　　　　　　out2。writeBytes（　　

　　　　　　　　　　〃Here's　the　value　of　pi：　n〃）；　　

　　　　　　　　out2。writeDouble（3。14159）；　　

　　　　　　　　out2。close（）；　　

　　　　　　　　DataInputStream　in5　=　　

　　　　　　　　　　new　DataInputStream（　　

　　　　　　　　　　　　new　BufferedInputStream（　　

　　　　　　　　　　　　　　new　FileInputStream（〃Data。txt〃）））；　　

　　　　　　　　System。out。println（in5。readLine（））；　　

　　　　　　　　System。out。println（in5。readDouble（））；　　

　　　　　　｝　catch（EOFException　e）　｛　　

　　　　　　　　System。out。println（　　

　　　　　　　　　　〃End　of　stream　encountered〃）；　　

　　　　　　｝　　

　　

　　　　　　//　6。　Reading/writing　random　access　files　　

　　　　　　RandomAccessFile　rf　=　　

　　　　　　　　new　RandomAccessFile（〃rtest。dat〃；　〃rw〃）；　　

　　　　　　for（int　i　=　0；　i　《　10；　i＋＋）　　

　　　　　　　　rf。writeDouble（i*1。414）；　　

　　　　　　rf。close（）；　　

　　

　　　　　　rf　=　　

　　　　　　　　new　RandomAccessFile（〃rtest。dat〃；　〃rw〃）；　　

　　　　　　rf。seek（5*8）；　　

　　　　　　rf。writeDouble（47。0001）；　　

　　　　　　rf。close（）；　　

　　

　　　　　　rf　=　　

　　　　　　　　new　RandomAccessFile（〃rtest。dat〃；　〃r〃）；　　

　　　　　　for（int　i　=　0；　i　《　10；　i＋＋）　　

　　　　　　　　System。out。println（　　

　　　　　　　　　　〃Value　〃　＋　i　＋　〃：　〃　＋　　

　　　　　　　　　　rf。readDouble（））；　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　295　


…………………………………………………………Page　297……………………………………………………………

　　　　　　rf。close（）；　　

　　

　　　　　　//　7。　File　input　shorthand　　

　　　　　　InFile　in6　=　new　InFile（args＇0＇）；　　

　　　　　　String　s3　=　new　String（）；　　

　　　　　　System。out。println（　　

　　　　　　　　〃First　line　in　file：　〃　＋　　

　　　　　　　　in6。readLine（））；　　

　　　　　　　　in6。close（）；　　

　　

　　　　　　//　8。　Formatted　file　output　shorthand　　

　　　　　　PrintFile　out3　=　new　PrintFile（〃Data2。txt〃）；　　

　　　　　　out3。print（〃Test　of　PrintFile〃）；　　

　　　　　　out3。close（）；　　

　　

　　　　　　//　9。　Data　file　output　shorthand　　

　　　　　　OutFile　out4　=　new　OutFile（〃Data3。txt〃）；　　

　　　　　　out4。writeBytes（〃Test　of　outDataFilenr〃）；　　

　　　　　　out4。writeChars（〃Test　of　outDataFilenr〃）；　　

　　　　　　out4。close（）；　　

　　

　　　　｝　catch（FileNotFoundException　e）　｛　　

　　　　　　System。out。println（　　

　　　　　　　　〃File　Not　Found：〃　＋　args＇0＇）；　　

　　　　｝　catch（IOException　e）　｛　　

　　　　　　System。out。println（〃IO　Exception〃）；　　

　　　　｝　　

　　｝　　

｝　///：~　　



10。5。1　输入流　　



当然，我们经常想做的一件事情是将格式化的输出打印到控制台，但那已在第5　章创建的　

。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　（字串缓冲　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　296　


…………………………………………………………Page　298……………………………………………………………

输入流）——作为构建器的参数，要求使用一个　String，而非一个　StringBuffer）。随后，我们用read（）　

依次读取每个字符，并将其发送至控制台。注意read（）将下一个字节返回为　int，所以必须将其造型为一个　

char，以便正确地打印。　　

　　

3。　格式化内存输入　　

StringBufferInputStream　的接口是有限的，所以通常需要将其封装到一个DataInputStream　内，从而增强　

它的能力。然而，若选择用readByte（）每次读出一个字符，那么所有值都是有效的，所以不可再用返回值来　

侦测何时结束输入。相反，可用available（）方法判断有多少字符可用。下面这个例子展示了如何从文件中　

一次读出一个字符：　　

　　

//：　TestEOF。java　　

//　Testing　for　the　end　of　file　while　reading　　

//　a　byte　at　a　time。　　

import　java。io。*；　　

　　

public　class　TestEOF　｛　　

　　public　stat　ic　void　main（String＇＇　args）　｛　　

　　　　try　｛　　

　　　　　　DataInputStream　in　=　　　

　　　　　　　　new　DataInputStream（　　

　　　　　　　　　new　BufferedInputStream（　　

　　　　　　　　　　new　FileInputStream（〃TestEof。java〃）））；　　

　　　　　　while（in。available（）　！=　0）　　

　　　　　　　　System。out。print（（char）in。readByte（））；　　

　　　　｝　catch　（IOException　e）　｛　　

　　　　　　System。err。println（〃IOException〃）；　　

　　　　｝　　

　　｝　　

｝　///：~　　

　　

注意取决于当前从什么媒体读入，avaiable（）的工作方式也是有所区别的。它在字面上意味着“可以不受阻　

塞读取的字节数量”。对一个文件来说，它意味着整个文件。但对一个不同种类的数据流来说，它却可能有　

不同的含义。因此在使用时应考虑周全。　　

为了在这样的情况下侦测输入的结束，也可以通过捕获一个违例来实现。然而，若真的用违例来控制数据　

流，却显得有些大材小用。　　

　　

4。　行的编号与文件输出　　

这个例子展示了如何LineNumberInputStream　来跟踪输入行的编号。在这里，不可简单地将所有构建器都组　

合起来，因为必须保持　LineNumberInputStream　的一个句柄（注意这并非一种继承环境，所以不能简单地将　

in4造型到一个　LineNumberInputStream）。因此，li　容纳了指向　LineNumberInputStream　的句柄，然后在　

它的基础上创建一个DataInputStream，以便读入数据。　　

这个例子也展示了如何将格式化数据写入一个文件。首先创建了一个　FileOutputStream，用它同一个文件连　

接。考虑到效率方面的原因，它生成了一个BufferedOutputStream。这几乎肯定是我们一般的做法，但却必　

须明确地这样做。随后为了进行格式化，它转换成一个PrintStream。用这种方式创建的数据文件可作为一　

个原始的文本文件读取。　　

标志DataInputStream　何时结束的一个方法是　readLine（）。一旦没有更多的字串可以读取，它就会返回　

null　。每个行都会伴随自己的行号打印到文件里。该行号可通过li　查询。　　

可看到用于　out1　的、一个明确指定的close（）。若程序准备掉转头来，并再次读取相同的文件，这种做法就　

显得相当有用。然而，该程序直到结束也没有检查文件IODemo。txt。正如以前指出的那样，如果不为自己的　

所有输出文件调用　close（），就可能发现缓冲区不会得到刷新，造成它们不完整。　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　297　


…………………………………………………………Page　299……………………………………………………………

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　快捷文件处理　　



由于以前采用的一些典型形式都涉及到文件处理，所以大家也许会怀疑为什么要进行那么多的代码输入——　

这正是装饰器方案一个缺点。本部分将向大家展示如何创建和使用典型文件读取和写入配置的快捷版本。这　

些快捷版本均置入package。bruceeckel。tools　中（自第5　章开始创建）。为了将每个类都添加到库内，　

只需将其置入适当的目录，并添加对应的package　语句即可。　　

　　

7。　快速文件输入　　

若想创建一个对象，用它从一个缓冲的DataInputStream　中读取一个文件，可将这个过程封装到一个名为　

InFile　的类内。如下所示：　　

　　

//：　InFile。java　　

//　Shorthand　class　for　opening　an　input　file　　

package　。bruceeckel。tools；　　

import　java。io。*；　　

　　

public　class　InFile　extends　DataInputStream　｛　　

　　public　InFile（String　filename）　　

　　　　throws　FileNotFoundException　｛　　

　　　　super（　　

　　　　　　new　BufferedInputStream（　　

　　　　　　　　new　FileInputStream（filename）））；　　

　　｝　　

　　public　InFile（File　file）　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　298　


…………………………………………………………Page　300……………………………………………………………

　　　　throws　FileNotFoundException　｛　　

　　　　this（file。getPath（））；　　

　　｝　　

｝　///：~　　

　　

无论构建器的String　版本还是File　版本都包括在内，用于共同创建一个　FileInputStream。　　

就象这个例子展示的那样，现在可以有效减少创建文件时由于重复强调造成的问题。　　

　　

8。　快速输出格式化文件　　

亦可用同类型的方法创建一个PrintStream，令其写入一个缓冲文件。下面是对。bruceeckel。tools　的扩　

展：　　

　　

//：　PrintFile。java　　

//　Shorthand　class　for　opening　an　output　file　　

//　for　human…readable　output。　　

package　。bruceeckel。tools；　　

import　java。io。*；　　

　　

public　class　PrintFile　extends　PrintStream　｛　　

　　public　PrintFile（String　filename）　　

　　　　throws　IOException　｛　　

　　　　super（　　

　　　　　　new　BufferedOutputStream（　　

　　　　　　　　new　FileOutputStream（filename）））；　　

　　｝　　

　　public　PrintFile（File　file）　　

　　　　throws　IOException　｛　　

　　　　this（file。getPath（））；　　

　　｝　　

｝　///：~