处理基本数据类型 Buffer 内幕 内存映像文件 性能 文件锁闭 压缩 生成 GZIP 压缩文件 对象串行化 恢复对象 正则表达式 生成正则表达式... 41

Transcription

1 第十三讲 Java I/O 系统 他应该瞪大眼睛盯着诺亚, 好好学习一下, 看他们是怎样把那么多东西装到一个小小的方舟上的 西德尼 十三 Java I/O 系统 第十三讲 Java I/O 系统 类 File... 3 列出文件夹的文件清单... 3 检查文件夹, 生成文件夹 输入输出... 6 InputStream 的类别...6 OutputStream 的类别 增加有用的属性和接口... 9 FilterInputStream 过滤输入流 FilterOutputStream 过滤输出流 Reader 及 Writer 数据源和数据汇点 改变数据流的行为 没有改变的类 RandomAccessFile I/O 流的使用方法 输入流 输出流 管道流 标准 I/O 从标准输入读入 将 System.out 转换为 PrintWriter...23 标准 I/O 重定向 新 I/O 数据转换 (1/52)

2 处理基本数据类型 Buffer 内幕 内存映像文件 性能 文件锁闭 压缩 生成 GZIP 压缩文件 对象串行化 恢复对象 正则表达式 生成正则表达式 Pattern 和 Matcher...45 find() Pattern 标志选项 split()...47 替换操作 正规表达式与 JavaI/O StringTokenizer 还有用吗? (2/52)

3 设计一个良好的输入 / 输出系统是语言设计人员的最难的工作之一 最大的挑战在于必须考虑各种可性能 输入输出不仅有多种数据源和数据汇点, 而且还要考虑与这些数据源 数据汇点的各种交流方式 ( 比如顺序访问 随机访问 缓存方式 二进制 字符形式 按行存取, 按单词存取等等 ) Java 类库设计人员通过很多类来完成这些功能, 实际上 JavaI/O 类库的类多得让人有些眼花 JavaI/O 类库在 Java1.0 之后也有很多改进, 在 Java1.2.0 中, 在原先面向字节的类库的基础上, 增加面向字符, 以 Unicode 为基础的 I/O 类库 而在 Java1.4 又新增了 nio 类库, 主要目的是改进 I/O 类库的性能和功能 由此, 在真正了解 JavaI/O 全貌, 能够利用类库之前, 我们必须掌握若干类的用法 同时, 了解 JavaI/O 的进化过程, 对于真正地理解 JavaI/O 类库也至关重要 1. 类 File 类 File 有一个令人迷惑的名称 我们首次看到它, 以为与文件相关, 实际上不是 : 它代表一个文件的名称或某个文件夹中一组文件的名称 当它代表一组文件时, 我们通过其 list() 方法, 获得该组文件的清单 列出文件夹的文件清单 当 File 对象指向一个文件夹时, 我们可以用两种方式列出其中的文件清单 当调用 list() 方法 而不给它任何参数时, 我们获得该文件夹中所有文件的清单 如果只想列出其中一部分文件, 比如只列出扩展名为.java 的文件, 我们就使用一个 FilenameFilter 对象来过滤这个清单 // Lec13: DirList.java import java.io.*; import java.util.*; import java.util.regex.*; public class DirList { public static void main(final String[] args){ File path = new File("."); String[] list; if(args.length == 0) list = path.list(); else 13-(3/52)

4 list = path.list(new FilenameFilter(){ private Pattern pattern = Pattern.compile(args[0]); public boolean accept(file dir, String name){ return pattern.matcher( new File(name).getName() ).matches(); ); Arrays.sort(list, new Comparator(){ public int compare(object o1, Object o2){ String s1 = (String)o1, s2 = (String)o2; return s1.tolowercase().compareto(s2.tolowercase()); ); for(int i=0; i<list.length; i++) System.out.println(list[i]); FilenameFilter 是一个非常简单的接口 : public interface FilenameFilter { boolean accept(file dir, String name); 其主要功能是定义 accept() 方法 方法 list() 通过回叫 accept() 来决定哪个文件名称应被包含在清单中 accept() 方法接受两个参数, 第一个参数是 File 对象, 表示文件所在的文件夹, 第二个参数是一个 String 对象, 表示文件的名称 DirList 中,accept() 方法利用一个正规表达式 Matcher 对象来判断这个正规表达式是否与文件名称相匹配 File.getName() 返回的是去掉路径名称之后的文件名 检查文件夹, 生成文件夹 我们也可以利用 File 对象生成一个新的文件夹或整个文件夹路径 我们也可以查阅文件的属 性 ( 如大小, 最后修改时间, 读写性等 ) 也可以判断一个 File 对象代表一个文件还是文件 夹 我们还可以用一个 File 对象删除一个文件 // Lec13: MakeDirectories.java import java.io.*; import java.util.*; public class MakeDirectories { private static void usage(){ 13-(4/52)

5 System.out.println( "Usage: MakeDirectories path1...\n" + "Creates each path.\n" + "Usage: MakeDirectories -d path1...\n" + "Deletes each path.\n" + "Usage: MakeDirectories -r path1 path2\n" + "Renames from path1 to path2."); System.exit(1); private static void filedata(file f){ System.out.println( "Absolute Path: " + f.getabsolutepath() + "\n Can Read: " + f.canread() + "\n Can write: " + f.canwrite() + "\n getname: " + f.getname() + "\n getparent: " + f.getparent() + "\n getpath: " + f.getpath() + "\n length: " + f.length() + "\n lastmodified: " + new Date(f.lastModified())); 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]); System.out.println("Renaming..." + old + " to " + rname); if(old.renameto(rname)) System.out.println("OK!"); else System.out.println("Failed!"); filedata(old); filedata(rname); return; int count = 0; boolean del = false; if(args[0].equals("-d")){ count++; del = true; count--; while(++count < args.length){ File f = new File(args[count]); if(f.exists()){ System.out.println(f + " exists"); if(del){ System.out.println("deleting..." + f ); 13-(5/52)

6 if(f.delete()) System.out.println("OK!"); else System.out.println("Failed!"); else{ // doesn't exist if(!del){ f.mkdirs(); System.out.println("created " + f); filedata(f); 程序中, 方法 filedata() 列出文件的有关属性 在 main() 方法中, 我们利用 renameto() 重新命 名文件, 利用 delete() 删除文件, 利用 mkdir() 生成文件夹 2. 输入输出 I/O 类库使用抽象概念 流, 用流表示任何可以产生或接受数据的数据源或数据汇点 流将实际 I/O 设备中的细节隐蔽了起来 JavaI/O 类库分为输入和输出两大类 : 派生自 InputStream 或 Reader 类的所有类均有 read() 方法, 它阅读一个单字节或一个字节数组 ; 派生自 OutputStream 或 Writer 类的所有类均具有 writer() 方法, 写出单个字节或一个字节数组 我们一般不直接使用这些方法, 它们存在的意义主要在于为别的更高级的类提供支持 这些更高级的类提供更有用的接口 在 Java1.0 中, 类库设计者决定所有与输入有关的类应该派生自 InputStream, 而所有与输出有关的类应该派生自 OutputStream InputStream 的类别 类 InputStream 代表各种从不同数据源产生输入的类 数据源可分为 13-(6/52)

7 1) 一个字节数组 2) 一个 String 对象 3) 一个文件 4) 一个管道 pipe 与物理管道一样, 从一端放入的事物从另一端出现 5) 一系列别的流, 组合成一个单一的流 6) 其它数据源, 如互联网连接 上述各数据源均由一个 InputStream 的子类描述 除此之外,FilterInputStream 也是一种 InputStream, 是一系列 装饰 类的基类 装饰类为 InputStream 新增一些有用的属性和接口 表 13-1 InputStream 的类别 类 ByteArrayInputStream StringBufferInputStrea m FileInputStream 功能将内存中的一块缓存作为 InputStream 使用将一个 String 对象转换为一个 InputStream 从文件阅读信息 构造方法的参数使用方法缓存, 以数组形式出现作为数据源 : 将其连接到一个 FilterInputStream 对象, 从而提供有用的接口一个 String 对象 后台使用的实际上是一个 StringBuffer 作为数据源 : 将其连接到一个 FilterInputStream 对象, 从而提供有用的接口一个代表文件名称的 String 对象, 或一个 File 对象, 或一个 FileDescripter 对象作为数据源 : 将其连接到一个 FilterInputStream 对象, 从而提供有用的接口 13-(7/52)

8 类 PipedInputStream SequenceInputStream FilterInputStream 功能与一个 PipedOutputStream 相连接 阅读写入那个 PipedOutputStream 的数据, 从而实现管道的概念 将两个或多个 InputStream 转换为一个 InputStream 是一个抽象类, 提供所有装饰类的接口, 从而为别的 InputStream 提供更有用的功能 详情况查表 13-3 构造方法的参数使用方法 PipedOutputStream 对象在多线程结构中, 作为数据源使用 将其连接到一个 FilterInputStream 对象, 从而提供更有用的接口 两个 InputStream 对象, 或一个包含了 InputStream 对象的容器的 Enumeration 对象 作为数据源 : 将其连接到一个 FilterInputStream 对象, 从而提供有用的接口查阅表 13-3 查阅表 13-3 OutputStream 的类别 表 13-2 OutputStream 的类别 类 ByteArrayOutputStream 功能在内存中生成一缓存, 写入该流的数据被存放在该缓存中 构造方法的参数用途 ( 可选 ) 缓存的初始大小指定数据的目的地 : 将其链接 - FilterOutputStream, 从而提供更有用的接口 13-(8/52)

9 类 FileOutputStream PipedOutputStream FilterOutputStream 功能将数据存入文件与一个 PipedInputStream 相连接 写入该输出流的数据将出现在对应的输入 构造方法的参数用途一个代表文件名称的 String 对象或一个 File, 或一个 FileDescriptor 对象指定数据的目的地 : 将其链接 - FilterOutputStream, 从而提供更有用的接口 PipedInputStream 对象在多线程结构中, 制定数据的目的地 将其与一个 FilterOutputStream 连接, 流, 从而实现管道的概念 从而提供更有用的接口 抽象类, 为所有输出装饰表 13-4 点提供接口, 从而为别的 OutputStream 提供更有用表 13-4 的接口 详情请查阅表 增加有用的属性和接口 利用分层对象动态地透明地为一对象增加职责的做法称为装饰模式 我们首先看看齐天大圣 的例子 13-(9/52)

10 齐天大圣是神仙类的一种, 如同 FileInputStream 或 ByteArrayInputStream 是 InputStream 的一 种 既然是神仙, 就可以变化, 但是变化后的神仙仍然是神仙 所以, 化身也是神仙的一种, 如同 FilterInputStream 也是一种 InputStream 不过无论怎样变化, 总是离不开神仙自己 所 以, 化身中也包含着神仙 孙猴有七十二变化, 可以变化为花 鸟 鱼 虫, 这些都是化身的分类 FilterInputStream 也有多种分类 孙猴可以在变成鱼之后, 再从鱼直接变成鸟, 也就是说, 装饰可以一层层叠 加上去 大圣孙悟空 = new 大圣 (); 鸟猴子变的鸟 = new 鸟 ( 孙悟空 ); 鱼猴子变的鱼 = new 鱼 ( 猴子变的鸟 ); Java 的输入流 输出流也可以层层装饰, 提供不同的 更多的功能 FilterInputStream 过滤输入流 FilterInputStream 称为过滤输入流, 它将另一个输入流作为数据源, 它与其它具体输入流的 关系, 如同 化身 与大圣的关系 表 13-3 FilterInputStream 的类别 类 DataInputStream 功能提供直接阅读基本数据类型数据 ( int,char,long 等 ) 的功能, 与 Dataoutputstream 配套使用 构造方法的参数用法 InputStream 对象阅读基本数据类型的数据, 以及 String 对象 13-(10/52)

11 类 BufferedInputStream LineNumberInputStream PushbackInputStream 功能用于缓存阅读, 从而避免每次阅读都直接从外存阅读, 改善性能 跟踪输入流中的行号 具有单个字节退回的缓存, 可以将最后一次读出的字节退回输入流 构造方法的参数用法 InputStream 以及缓存大小 ( 可选 ) 不额外增加接口, 只是增加了缓存的功能 InputStream 对象 InputStream 对象一般用于编译器程序的扫描程序, 通常不太使用 FilterOutputStream 过滤输出流 DataOutputStream 能够将基本数据类型和 String 对象写入到输出流 与 DataInputStream 配套使用 PrintStream 的主要意图是将所有基本数据类型和 String 对象以人类可见的形式打印出来 注意它与 DataOutputStream 的区别 PrintStream 将捕获所有 IOException, 所以为了检查错误情况, 我们必须调用 checkemor() 方法来查询 : 如果发生了错误, 这个方法返回 true,printstream 也不能正确地处理如汉字等语言, 这些问题在 PrintWriter 中得到了解决 13-(11/52)

12 BufferedOutputStream 不提供额外的接口, 它所完成的唯一功能是提供缓存, 从而改善硬件 的访问速度 表 13-4 FilterOutputStream 的类别 类 DataOutputStream PrintStream BufferedOutputStream 功能与 DataInputStream 配套使用完成基本数据类型的读写打印 缓存 构造方法的参数用法 Outputstream 基本数据类型和 String Outputstream 以及可选的逻辑参数, 指定每个换行缓存是否刷新 应该为装饰类的最后一层 OutputStream 以及缓存的大小 ( 可选 ) 缓存 4.Reader 及 Writer Java1.1 对基本 I/O 系统做了较大的改动, 新推出了 Reader 和 Writer 类以及其子类 装饰类 新推出的 Reader 和 Writer 类是对 InputStream 和 OutputStream 的补充 InputStream 和 OutputStream 是面向字节的, 而 Reader 和 Writer 是面向字符的, 能够处理 Unicode Java1.1 也给 InputStream 和 OutputStream 新增了子类, 也增加了适配类 InputStreamReader 和 OutputStreamWriter, 分别将 InputStream 和 OutputStream 转换为 Reader 和 Writer 推出 Reader 和 Writer 的最大的动机是支持国际化 旧的 I/O 流只支持 8 位字节, 而不能很好地支持 16 位 Unicode 字符 13-(12/52)

13 数据源和数据汇点 几乎所有的 I/O 流类都有对应的 Reader 和 Writer 但这并不意味着我们总是使用后者, 在有些地方, 面向字节的 InputStream 和 OutputStream 是正确的选择 比如,java.util.zip 类库就是面向字节的 比较合理的做法是, 首先试着使用 Reader 和 Writer, 而必需时, 使用 InputStream 和 OutputStream 下表显示了这两个系统中数据源和汇点的对应关系 表 :13-5 源和汇点 Java 1.0 Java 1.1 Reader InputStream 适配器 :InputStreamReader Writer OutputStream 适配器 :OutputStreamWriter FileInputStream FileReader FileOutputStream FileWriter StringBufferInputStream StringReader - StringWriter ByteArrayInputStream CharArrayReader ByteArrayOutputStream CharArrayWriter PipeInputStream PipedReader PipedOutputStream PipedWriter 一般来讲, 这两个系统具有相同或相似的接口 改变数据流的行为 对于 InputSream 和 OutputStream, 我们利用适当的装饰类 ( FilterInputStream 和 FilterOutputstream 的子类 ) 对他们装饰, 从而满足特殊的需求 Reader 和 Writer 类也利用同 样的概念, 但有所区别 13-(13/52)

14 下表列出了 Java1.0 装饰类与 Java1.1 装饰类之间的比较 表 :13-6 过滤类 Java 1.0 Java 1.1 FilterInputStream FilterReader FilterOutputStream FilterWriter ( 抽象类, 但是没有派生类 ) BufferedInputStream BufferedReader ( 同样提供 readline() 方法 ) BufferedOutputStream BufferedWriter PrintStream PrintWriter LineNumberInputStream (deprecated) LineNumberReader StreamTokenizer StreamTokenizer ( 使用接受 Reader 的构造方法 ) PushBackInputStream PushBackReader 主要区别在于类的组织 : 13-(14/52)

15 尽管如此,Java1.0 和 Java1.1 对应类的接口还是相当接近的 当需要用到 realine() 方法时不 应再使用 DataInputStream, 而应使用 BufferedReader, 除此之外 DataInputStream 还是 I/O 类 库的可取的一个类 13-(15/52)

16 没有改变的类 有些类从 Java1.0 升级到 Java1.1 的过程中没有改变 : DataOutputStream File RandomAccessFile SequenceInputStream 5.RandomAccessFile RandomAccessFile 用于存储已知大小的纪录的文件, 我们可以使用 seek() 方法定位一个记录, 13-(16/52)

17 然后访问它或修改它 RandomAccessFile 不是 InputStream 或 OutputStream 系统中的一员, 它与它们无关 如果说有共同点的话, 那就是 RandomAccessFile 也实现了 DataInput 和 DataOutput 接口, 而这两个接口也分别被 DataInputStream 和 DataOutputStream 实现 RandomAccessFile 的 length() 方法返回文件的最大长度, 方法 seek() 将文件指针移动到指定的位置 我们通过给 RandomAccessFile 的构造方法传递不同的参数, 决定文件是可读可写的 ( rw") 还是只读的 ( r ) 在 Java1.4 中,RandomAccessFile 的大多数功能由 nio 内存映射文件代替了 6.I/O 流的使用方法 尽管我们可以将 I/O 流的各种类以不同的方式组合起来, 但是一般情况下, 我们只是用少数 几种组合, 下面的例子可以作为参考 例中包含了各种 I/O 配置的生成和使用方法, 我们标注了编号, 对应于程序后的注解 // Lec13: IOStreamDemo.java import java.io.*; public class IOStreamDemo { public static void main(string[] args) throws IOException { // 1). 按行阅读 BufferedReader in = new BufferedReader( new FileReader("IOStreamDemo.java")); String s; StringBuffer sb = new StringBuffer(); while((s = in.readline())!= null) sb.append(s + "\n"); String s2 = sb.tostring(); // 1b). 标准输入 BufferedReader stdin = new BufferedReader( new InputStreamReader( System.in )); System.out.print("Enter a line: "); System.out.println(stdin.readLine()); 13-(17/52)

18 // 2). 从内存输入 StringReader in2 = new StringReader(s2); int c; while((c = in2.read())!= -1) System.out.print((char)c); System.out.print("Press Enter: "); stdin.readline(); // 3). 格式化内存输入 try{ DataInputStream in3 = new DataInputStream( new ByteArrayInputStream(s2.getBytes())); while(true) System.out.print((char)in3.readByte()); catch(eofexception e){ System.err.println("End of Stream"); // 4). 文件输出 try{ BufferedReader in4 = new BufferedReader( new StringReader(s2)); PrintWriter out1 = new PrintWriter( new BufferedWriter( new FileWriter("IODemo.out") ) ); int linecount = 1; while((s = in4.readline())!= null) out1.println(linecount++ + ": " + s); out1.close(); catch(eofexception e){ System.err.println("End of Stream"); // 5). 存储并恢复数据 try{ DataOutputStream out2 = new DataOutputStream( new BufferedOutputStream( new FileOutputStream( "Data.txt" ) ) ); out2.writedouble( ); out2.writeutf("this was pi"); out2.writedouble( ); out2.writeutf("square root of 2"); out2.close(); DataInputStream in5 = new DataInputStream( new BufferedInputStream( new FileInputStream( "Data.txt" ))); System.out.println(in5.readDouble()); System.out.println(in5.readUTF()); System.out.println(in5.readDouble()); 13-(18/52)

19 System.out.println(in5.readUTF()); catch(eofexception e){ throw new RuntimeException(e); // 6). 读写随机存取文件 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( ); rf.close(); rf = new RandomAccessFile("rtest.dat", "r"); for(int i=0; i<10; i++) System.out.println("Value " + i + ": " + rf.readdouble()); rf.close(); 输入流 程序中第 1) 至第 4) 部分演示了输入流的用法 1) 缓存输入文件为了进行字符输入, 我们使用 FileReader FileReader 的构造方法接受一个 String 或 File 代表文件名称 为了提高速度, 我们希望使用缓存, 所以, 我们将 FileReader 对象传递给 BufferedReader 的构造方法 BufferedReader 提供 readline() 接口 当阅读到文件结束时,readLine() 返回 null 我们使用这个值退出循环 ReadLine() 在读入行时, 自动将换行符丢弃了, 所以, 我们在用 StringBuffer.append() 时, 增加了换行符 最后, 我们通过调用 close() 方法关闭文件 1b) 显示了如何将 System.in 包装起来, 进行控制台输入的方法 System.in 是一个 InputStream, 而 BufferedReader 构造方法需要的是一个 Reader, 所以我们使用 InputStreamReader 将其转换为 Reader 2) 从内存输入 13-(19/52)

20 s2 包含了文件的所有内容, 我们利用它生成一个 StringReader 我们利用 read() 方法每 次读入一个字符, 并将它送到控制台 值得注意的是 read() 方法将下一个字符作为整 数返回, 所以必须将其转换为 char 3) 格式化内存输入 为了读入格式化的数据, 我们必须使用 DataInputStream 我们通过 String.getBytes() 方 法将 String 转换为字节数组, 然后利用这个数组生成一个 ByteArrayInputStream 当我们从 DataInputStream 每次读入一个字节时, 读入的任何值都是合法的, 所以, 不能通过 readbytes() 的返回值判断输入的终止 我们可以使用 available() 方法检查尚有多少字节 : // Lec13: TestEOF.java import java.io.*; public class TestEOF { // 将异常抛到控制台 public static void main(string[] args) throws IOException { DataInputStream in = new DataInputStream( new BufferedInputStream( new FileInputStream(new File("TestEOF.java")))); while(in.available()!= 0) System.out.print((char)in.readByte()); 注意 available() 方法对不同的输入流产生不同的结果 它返回的数字表示还能从数据源中读入的字节数 用于文件时, 表示文件中剩余的字节数 但对于别的输入流, 如管道, 则意义又有变化 所以, 使用时一定要注意 我们也可以利用异常来检测文件的结果 不过这种做法通常被认为是异常的错误用法 4) 文件输出这个例子也显示了如何将数据写入文件 首先, 我们生成一个 FileWriter 通常我们都希望利用缓存, 所以, 我们又利用这个 FileWriter 对象生成一个 BufferedWriter 最后, 我们又将 BufferedWriter 装饰为一个 PrintWriter 按上述方式生成的文件可作为普通的文本文件阅读 在将每一行写入文件时, 我们加 13-(20/52)

21 上了行号, 注意我们并没有使用 LineNumberInputStream, 因为这是一个愚蠢的类, 一般不用它 例中显示, 跟踪行号实际上是一个非常简单的工作 在输入文件读完之后,readLine() 返回 null 注意必须记得调用 close() 方法, 否则, 因为缓存没有刷新, 文件将不完全 输出流 输出流接其输出格式可分为两大类, 一类是用于人类查看的, 以人类可以辨识的格式输出数据, 另一类则是与 DataInputStream 配套使用的 RandomAccessFile 独立于这两大类, 但是其数据格式与 DataInputStream 和 DataOutputstream 兼容 5) 存储并恢复数据 PrintWriter 以人类可以阅读的格式输出数据 如果我们的目的是输出数据, 然后由另外一个输入流恢复数据, 那么, 我们用 DataOutputStream 保存数据, 用 DataInputStream 恢复数据 如果使用 DataOutputStream 保存数据,Java 保证无论在哪个平台, 我们都可以用 DataInputStream 正确无误的恢复数据 在使用 DataInputStream 和 DataOutputStream 时, 存取 String 对象的可靠的方法是使用 WriteUTF() 方法和 readutf() 方法, 这些方法用 UTF-8 编码保存 String UTF-8 是 Unicode 的一个变种, 它用一个字节保存 ASCII 字符, 用两到三个字节保存非 ASCII 字符, 字符串的长度保存在前两个字节 6) 读写随机访问文件如前面所述,RandomAccessFile 几乎完全与其它 I/O 系统隔绝 它与其它 I/O 系统的唯一共同点就是它实现了 DataInput 和 DataOutput 接口 RandomAccessFile 的构造方法的第二个参数决定文件的读写性, r 表示只读, 而 rw 表示可读可写 因为 Java1.4 的出现, 实际上我们应考虑用内存映射的文件替代 RandomAccessFile 13-(21/52)

22 管道流 目前为止, 我们只是简单第提及了 PipedInputStream,PipedOutputstream,PipedReader, PipedWriter 这不意味着它们不重要, 而是因为只有了解了多线程的概念之后, 我们才能体 会其价值 7. 标准 I/O 标准 I/O 的概念来自于 Unix Unix 程序经常假定其信息来自同一个数据源, 而其结果总是输出到同一个数据汇点, 这就是标准输入和标准输出 程序的错误信息则总是输出到标准错误输出 标准 I/O 的价值在于多个程序可以直接链接起来, 一个程序的标准输出可以变成另一个程序的标准输入, 这是一个非常有用的工具 从标准输入读入 按照标准 I/O 的模式,Java 提供了 System.in,System.out 以及 System.err System.out 和 System.err 已经被包裹为 PrintStream 对象, 而 System.in 则是一个没有任何装饰 的 InputStream 所以为了使用 System.in, 我们必须对它进行必要的装饰 一般情况下, 我们希望从标准输入一次读入一行, 所以, 通常将 System.in 转换为一个 BufferedReader, 然后使用其 readline() 方法 : // Lec13: Echo.java import java.io.*; public class Echo { public static void main(string[] args) throws IOException { BufferedReader in = new BufferedReader( new InputStreamReader(System.in)); String s; while((s = in.readline())!= null && s.length()!= 0) System.out.println(s); 13-(22/52)

23 将 System.out 转换为 PrintWriter System.out 是一个 PrintStream, 不能正确地处理多字节文字 所以有时需要将其转换为 PrintWriter PrintWriter 的一个构造方法接受 OutputStream 对象, 所以, 可以直接转换 : // Lec13: ChangeSystemOut.java import java.io.*; public class ChangeSystemOut { public static void main(string[] args){ PrintWriter out = new PrintWriter(System.out, true); out.println(" 幸福的家庭都很相像, 而不幸的家庭各有各的问题!"); 注意我们必须使用接受两个参数的构造方法, 用第二个参数数据指定其进行自动缓存刷新, 否则, 我们将看不到输出 标准 I/O 重定向 System 类允许我们利用下列简单的方法重定向标准 I/O SetIn(InputStream) SetOut(PrintStream) SetIn(PrintStream) 请看下面的例子 : // Lec13: Redirecting.java import java.io.*; public class Redirecting { public static void main(string[] args) throws IOException { PrintStream console = System.out; BufferedInputStream in = new BufferedInputStream( new FileInputStream("Redirecting.java")); PrintStream out = new PrintStream( new BufferedOutputStream( new FileOutputStream("test.out"))); System.setIn(in); System.setOut(out); BufferedReader br = new BufferedReader( new InputStreamReader(System.in)); String s; 13-(23/52)

24 while((s = br.readline())!= null) System.out.println(s); out.close(); System.setOut(console); System.out.println(" 请察看文件 \"test.out\""); 这个程序将标准输入连接到一个文件, 而将标准输出重新定向到另一个文件 8. 新 I/O Java1.4 中在 java.nio 包中推出了新 I/O, 其主要目的是改善速度 实际上, 老的 I/O 系统在 java1.4 中也已经利用这个新技术重新实现过了 所以, 既或我们不明确使用 nio 的类, 也能 享受 Java1.4 提供的性能改进 Java1.4 利用与操作系统相近的方式处理输入输出 : 通道 (channel) 和缓存 (buffer) 可以将这种新的结构想象为一个煤矿 : 通道是包含了煤层的煤矿, 而 buffer 就像送入煤矿的 推车 推车回来时装满了煤, 我们从车中获得煤, 也就是说我们不直接与通道接触, 而是通 过 buffer 与之接触, 通道可以从 buffer 中取得数据, 也可以将数据装入 buffer 中, 与 Channel 直接接触的 buffer 是 ByteBuffer ByteBuffer 是非常具体的类, 我们在调用其构造方法时, 直接指明 buffer 的大小,ByteBuffer 同时也提供了读写基本数据类型的接口, 但它不提供 String 的读写和其他对象的读写 旧的 I/O 系统中三个类 FileInputStream FileOutputStream 以及 RandomAccessFile 被修改, 通 过方法 getchannel() 产生一个 Filechannel 注意上述三个被修改的流均是面向字节的 Reader 和 Writer 类不生成 Channel 应用程序类 java.nio.channels.channels 提供方法, 将 Channel 转换为 Reader 或 Writer 下面是利用 FileInputStream FileOutputStream 以及 RandomAccessFile 生成 Channel 的例子 // Lec13: GetChannel.java import java.io.*; import java.nio.*; import java.nio.channels.*; 13-(24/52)

25 public class GetChannel { private static final int BSIZE = 1024; private static final String F_NAME = "data.txt"; public static void main(string[] args) throws Exception { // 写文件 FileChannel fc = new FileOutputStream(F_NAME).getChannel(); fc.write(bytebuffer.wrap("hello( 您好 ) ".getbytes())); fc.close(); // 加到文件末尾 fc = new RandomAccessFile(F_NAME, "rw").getchannel(); fc.position(fc.size()); fc.write(bytebuffer.wrap("world( 世界 )!".getbytes())); fc.close(); // 读文件 fc = new FileInputStream(F_NAME).getChannel(); ByteBuffer buff = ByteBuffer.allocate(BSIZE); fc.read(buff); buff.flip(); while(buff.hasremaining()) System.out.print((char)buff.get()); 程序运行时显示 : Hello???????? World????????! 如程序所示,FileInputStream FileOutputStream 以及 RandomAccessFile 的 getchannel() 方法返回一个 FileChannel 对象 我们利用 FileChannel 的 read() 和 write() 方法用 ByteBufferr 访问文件 ( 读写文件 ) 将数据装入 ByteBuffer 的方法之一是利用各种 put 方法将字节数组或基本填入 ByteBuffer 然而, 如程序所示, 我们也可以调用 ByteBuffer.wrap() 方法, 将一字节数组包裹, 形成一个新的 ByteBuffer 在利用 wrap() 生成新的 ByteBuffer 时, 字节数组并没有被复制到 ByteBuffer 中, 它被直接用到 ByteBuffer 中 我们称产生的 ByteBuffer 由字节数组支持 Java.nio 目的是追求更快的速度 所以在从 channel 读取数据时, 我们应使用足够大的 ByteBuffer 我们用 ByteBuffer.allocate() 方法生成一个 ByteBuffer,ByteBuffer 的大小一般为 1024 的倍数 13-(25/52)

26 在调用 Filechannel 的 read() 方法, 将数据装入 ByteBuffer 之后, 应该调用 flip() 方法, 使得缓 存准备好从其中抽取数据 请看如下一个简单的文件拷贝程序 // Lec13: ChannelCopy.java import java.io.fileinputstream; import java.io.fileoutputstream; import java.nio.bytebuffer; import java.nio.channels.filechannel; public class ChannelCopy { private static final int BSIZE = 1024; public static void main(string[] args) throws Exception { if(args.length!= 2) { System.out.println(" 参数 : 源文件目标文件 "); System.exit(1); FileChannel in = new FileInputStream(args[0]).getChannel(), out = new FileOutputStream(args[1]).getChannel(); ByteBuffer buffer = ByteBuffer.allocate(BSIZE); while(in.read(buffer)!= -1) { buffer.flip(); // Prepare for writing out.write(buffer); buffer.clear(); // Prepare for reading 程序中打开了两个 FileChannel, 分别用于读和写 生成了一个 ByteBuffer, 用于读写 当 filechannel.read() 返回 -1 时, 表示已到达输入通道的末端 方法 read() 将数据装入 ByteBuffer 之后,ByteBuffer.flip() 使得该 ByteBuffer 准备妥当, 便于从中提取数据 方法 write() 将 ByteBuffer 中的数据写入该 FileChannel 在调用 write() 之后, 数据仍然保留在 ByteBuffer 之中,clear() 方法将 ByteBuffer 内部的所有指针复位, 便于下次 read() 时接受数据 但是上述数据并不是处理这类事物的最佳的方式 FileChannel 的 transferto() 和 transferfrom() 方法允许我们直接将一个 Channel 连接到另一个 Channel: // Lec13: Transfer.java 13-(26/52)

27 import java.io.*; import java.nio.channels.*; public class Transfer { public static void main(string[] args) throws Exception { if(args.length!= 2){ System.out.println(" 参数 : 源文件目标文件 "); System.exit(1); FileChannel in = new FileInputStream(args[0]).getChannel(); FileChannel out = new FileOutputStream(args[1]).getChannel(); in.transferto(0, in.size(), out); // 或者 out.tranferfrom(in, 0, in.size()); 数据转换 回头看看 GetChannel.Java, 为了打印文件中的信息, 我们每次从 ByteBuffer 中读取一个字节, 然后将其转换为 char, 并打印 这种方式太原始, 而且不能正确处理多字节文字 ByteBuffer 包含的是纯二进制数据, 为了显示其中的内容, 必须对数据进行转换 ( 编码 ) // Lec13: BufferToText.java import java.io.*; import java.nio.*; import java.nio.channels.*; import java.nio.charset.*; public class BufferToText { static abstract class Test { private String name; public static final String TXT = " 包含中文 English 以及 123 数字的文字 "; Test(String n){ name = n; protected ByteBuffer writeandread(bytebuffer in) throws Exception { System.out.println(name); System.out.println("remaining: " + in.remaining()); File file = new File("data2.txt"); FileChannel fc = new FileOutputStream(file).getChannel(); fc.write(in); fc.close(); fc = new FileInputStream(file).getChannel(); ByteBuffer out = ByteBuffer.allocate(1024); fc.read(out); out.flip(); 13-(27/52)

28 fc.close(); return out; protected void check(string s){ System.out.println(" [" + s + "]"); if(txt.equals(s)) System.out.println("...OK"); else System.out.println("...Error"); public abstract void test() throws Exception; static Test[] tests = { new Test("1 不做转换 "){ public void test() throws Exception { ByteBuffer out = writeandread(bytebuffer.wrap(txt.getbytes())); check(out.ascharbuffer().tostring());, new Test("2 读出后用当前缺省字符集解码 "){ public void test() throws Exception { Charset cs = Charset.forName(System.getProperty("file.encoding")); ByteBuffer out = writeandread(bytebuffer.wrap(txt.getbytes())); String result = cs.decode(out).tostring(); check(result);, new Test("3 写入前用 UTF-16BE 编码 "){ public void test() throws Exception { Charset cs = Charset.forName("UTF-16BE"); ByteBuffer in = cs.encode(txt); ByteBuffer out = writeandread(in); check(out.ascharbuffer().tostring());, new Test("4 用 getbytes() 编码 "){ public void test() throws Exception { ByteBuffer out = writeandread( ByteBuffer.wrap(TXT.getBytes("UTF-16BE"))); check(out.ascharbuffer().tostring());, new Test("5 通过 CharBuffer 写入 "){ public void test() throws Exception { ByteBuffer in = ByteBuffer.allocate(100); 13-(28/52)

29 in.ascharbuffer().put(txt); ByteBuffer out = writeandread(in); check(out.ascharbuffer().tostring());, ; public static void main(string[] args) throws Exception { for(int i=0; i<tests.length; i++) tests[i].test(); 该程序在运行时显示 : 1 不做转换 remaining: 34 [?????? 杬楳棒????????]...Error 2 读出后用当前缺省字符集解码 remaining: 34 [ 包含中文 English 以及 123 数字的文字 ]...OK 3 写入前用 UTF-16BE 编码 remaining: 44 [ 包含中文 English 以及 123 数字的文字 ]...OK 4 用 getbytes() 编码 remaining: 44 [ 包含中文 English 以及 123 数字的文字 ]...OK 5 通过 CharBuffer 写入 remaining: 100 [ 包含中文 English 以及 123 数字的文字...Error 在第一个测试中, 我们试着用 ByteBuffer 的 ascharbuffer() 方法将 ByteBuffer 转换为 CharBuffer, 然后显示 CharBuffer 的内容, 结果证明, 这种办法并不能正确显示 在第二个测试中, 从文件读出数据之后, 我们利用系统当前的缺省字符集对其进行解码 运 行结果正确 System.getProperty("file.ercoding") 返回了当前字符集的名称 CharSet.decode() 接受一个 ByteBuffer, 将其解码, 返回一个 CharBuffer 在第三个测试中, 我们利用 CharSet.encode(String) 方法, 对字符串中的信息进行编码, 其返 13-(29/52)

30 回结果为 ByteBuffer 运行结果正确 第四个测试中展示了另外一种编码方法 : 利用 String.getBytes(String) 方法 第五个测试中我们利用 CharBuffer 来写入数据, 从结果看出, 尽管我们写的信息是可见的形式出现了, 但是 CharBuffer 中空闲的空间也被 ByteBuffer 当作有用的信息接受了过来 处理基本数据类型 尽管 ByteBuffer 只存储二进制数据, 但它却提供方法处理各基本类型的数据 下面的例子利 用这些方法将基本类型的数据插入 ByteBuffer 以及从 ByteBuffer 读取基本数据类型的数据 // Lec13: GetData.java import java.nio.*; public class GetData { public static void main(string[] args){ ByteBuffer buff = ByteBuffer.allocate(1024); buff.putchar('a'); buff.putshort((short)23); buff.putdouble( ); buff.flip(); System.out.println(buff.getChar()); System.out.println(buff.getShort()); System.out.println(buff.getDouble()); 程序运行时显示 : A Buffer 内幕 Buffer 由数据以及四个变址组成 四个变址是 mark positon limit capacity mark position 标记, 用于记住某一位置 表示 Buffer 中当前的指针, 是每次写入或提取数据的位置 13-(30/52)

31 mark limit capacity 标记, 用于记住某一位置 有两个用途 : 在写入时,limit 表示写入的范围, 我们只能从 position 位置开始写入, 至到 limit 为止 如果写入过程中, 导致 position 到达 limit 所指的位置, 那么, 会产生异常 在写入完毕后, 为了从中提取数据, 要求调用 flip() 方法, 该方法将 limit 指向当前 position 所指的位置, 而将 position 设置为 0 由此, 可以从 0 开始提取数据, 直到 limit 为止 方法 remainning() 返回的数据实际上就是 limit-position 表示 Buffer 的容量, 一旦生成就保持不变 Buffer 还提供了几个方法, 可以查询或设置上述几个变址, 其中,limit() 返回当前的 limit 值, 而 limit(int) 方法设置 limit 值 同样 position() 方法返回当前 position 的值, 而 position(int) 设置 position 的值 方法 mark() 则将 mark 值设置为当前的 position 值 在调用 reset() 方法时,position 就恢复为 mark 的值 方法 clear() 将 position 设置为 0, 而将 limit 设置为 capacity 如前所述,flip() 的作用是将 limit 设置为当前的 position 值 而将 position 设置为 0, 这意味着如果连续调用两次 flip() 方法, 则 Buffer 的 position 和 limit 都将为 0, 从而既不能写入也无法读出 内存映像文件 内存映像文件, 允许我们生成并处理那些太大, 不能完全装入内存的文件 使用内存映像文件时, 我们可以认为整个文件都在内存中, 所以可以当作一个非常大的数组 来处理它 这种方式极大地简化了文件处理 下面是一个简单的示例 : // Lec13: LargeMappedFile.java import java.io.randomaccessfile; import java.nio.mappedbytebuffer; import java.nio.channels.filechannel; public class LargeMappedFile { 13-(31/52)

32 static int length = 0x8FFFFFF; // 128 Mb public static void main(string[] args) throws Exception { MappedByteBuffer out = new RandomAccessFile("test.dat", "rw").getchannel().map(filechannel.mapmode.read_write, 0, length); for(int i = 0; i < length; i++) out.put((byte)'x'); System.out.println("Finished writing"); for(int i = length/2; i < length/2 + 6; i++) System.out.print((char)out.get(i)); 为了进行读写, 我们首先生成一个 RandomAccessFile, 然后生成一个 channel, 并用该 Channel 的 map() 方法生成一个 MappedByteBuffer MappedByteBuffer 实际上是 Buffer 的一种特例, 所以具有 Buffer 的所有接口 在生成 MappedByteBuffer 时, 需要指明文件中映像的区域的起始位置和长度 这实际上也意味着我们可以选择映像一个大的文件的一部分到内存 性能 尽管旧的输入输出流系统已经利用 nio 技术更新了, 映像文件的读写速度还是比输入输出流 快得很多 下列程序进行简单的性能比较 // Lec13: MappedIO.java import java.io.*; import java.nio.*; import java.nio.channels.*; public class MappedIO { private static int numofints = ; private abstract static class Tester { protected File file = new File("tmp.dat"); private String name; public Tester(String s){ name = s; public long runtest(){ System.out.print(name + ": "); try{ long t1 = System.currentTimeMillis(); test(); long t2 = System.currentTimeMillis(); System.out.println(t2-t1); return (t2-t1); catch(ioexception e){ 13-(32/52)

33 throw new RuntimeException(e); public abstract void test() throws IOException; private static Tester[] tests = { new Tester("Stream Write"){ public void test() throws IOException { DataOutputStream dos = new DataOutputStream( new BufferedOutputStream( new FileOutputStream(file))); for(int i=0; i<numofints; i++) dos.writeint(i); dos.close();, new Tester("Mapped Write"){ public void test() throws IOException { FileChannel fc = new RandomAccessFile(file, "rw").getchannel(); IntBuffer ib = fc.map(filechannel.mapmode.read_write, 0, numofints * 4).asIntBuffer(); for(int i=0; i<numofints; i++) ib.put(i); fc.close();, new Tester("Stream Read"){ public void test() throws IOException { DataInputStream dis = new DataInputStream( new BufferedInputStream( new FileInputStream(file))); for(int i=0; i<numofints; i++) dis.readint(); dis.close();, new Tester("Mapped Read"){ public void test() throws IOException { FileChannel fc = new FileInputStream(file).getChannel(); IntBuffer ib = fc.map(filechannel.mapmode.read_only, 0, fc.size()).asintbuffer(); for(int i=0; i<numofints; i++) ib.get(); fc.close();, new Tester("Stream Read/Write"){ public void test() throws IOException { RandomAccessFile raf = new RandomAccessFile(file, "rw"); raf.writeint(1); 13-(33/52)

34 for(int i=0; i<numofints; i++){ raf.seek(raf.length()-4); raf.writeint(raf.readint()); raf.close();, new Tester("Mapped Read/Write"){ public void test() throws IOException { FileChannel fc = new RandomAccessFile(file, "rw").getchannel(); IntBuffer ib = fc.map(filechannel.mapmode.read_write, 0, fc.size()).asintbuffer(); ib.put(0); for(int i=1; i<numofints; i++) ib.put(ib.get(i-1)); fc.close();, ; public static void main(string[] args){ for(int i=0; i<tests.length; i++) tests[i].runtest(); 这个程序在不同的情况下, 运行结果可能有所变化 下列是一次运行的结果 : Stream Write: 31 Mapped Write: 16 Stream Read: 16 Mapped Read: 0 Stream Read/Write: 1766 Mapped Read/Write: 15 从这个结果看, 尽管映像文件的初始化成本较大, 但总体性能比旧的 I/O 系统要好出很多 程序中, 内部类映像 Tester 提供了测试的基本框架 runtest() 方法提供了测试的流程, 每个具体测试类必须提供的方法 test() 就是具体的测试内容 如程序中所示, 映像写入必须使用 RandomAccessFile 来生成 Channel, 而不能使用 FileOutputStream 文件锁闭 JDK1.4 引入了文件锁闭的概念, 利用文件锁闭的机制, 可以同步对共享文件资源的访问 Java 文件锁闭直接映射到操作系统的锁闭功能, 所以, 哪怕共享资源的别的线程不是 Java 实现的 它也能感受到文件锁闭的作用 13-(34/52)

35 // Lec13: FileLocking.java import java.io.fileoutputstream; import java.nio.channels.filelock; public class FileLocking { public static void main(string[] args) throws Exception { FileOutputStream fos = new FileOutputStream("file.txt"); FileLock fl = fos.getchannel().trylock(); if(fl!= null) { System.out.println("Locked File"); Thread.sleep(10000); fl.release(); System.out.println("Released Lock"); fos.close(); 我们通过 trylock() 或 lock() 方法获得对整个文件的锁闭 trylock() 是非阻塞形的方法, 如果锁闭成功, 它返回一个 Filelock, 如果锁闭失败, 则返回 null 方法 lock() 是阻塞形的, 只有获得了对资源的锁闭, 才返回一个 Filelock 我们通过方法 Filelock.release() 释放对资源的锁闭 9. 压缩 JavaI/O 系统还包含支持读写压缩格式的文件的类 这些类都通过包裹已有的 I/O 类来提供压缩功能 这些类不是派生的 Reader 和 Writer, 而是派生自 InputStream 和 OutputStream 体系, 这是因为压缩是按字节而不是按字符工作的 压缩类 CheckedInputStream CheckedInputStream DeflaterOutputStream ZipOutputStream GZIPOutputStream 功能为任何 InputStream 产生校验码为任何 OutputStream 生成校验码压缩类的基类按 zip 文件格式压缩按 GZIP 文件格式压缩 13-(35/52)

36 压缩类 InflaterInputStream ZipInputStream GzipInputStream 解压类的基类 解压 zip 文件 解压 Gzip 文件 功能 尽管有许多压缩算法, 但 zip 和 GZIP 大概是最常用的 生成 GZIP 压缩文件 GZIP 文件的接口非常简单, 适于压缩单一数据源的数据 // Lec13: GZIPcompress.java import java.io.*; import java.util.zip.*; public class GZIPcompress { public static void main(string[] args) throws IOException { if(args.length == 0){ System.out.println( " 用法 : java GZIPcompress 被压缩的文件名称 \n" + " 使用 GZIP 压缩算法将文件压缩到 test.gz"); System.exit(1); BufferedReader in = new BufferedReader(new FileReader(args[0])); PrintWriter out = new PrintWriter( new BufferedWriter( new OutputStreamWriter( new GZIPOutputStream( new FileOutputStream("test.gz"))))); System.out.println("Writing file"); String s; while((s = in.readline())!= null) out.println(s); in.close(); out.close(); System.out.println("Reading file"); BufferedReader in2 = new BufferedReader( new InputStreamReader( new GZIPInputStream( new FileInputStream("test.gz")))); while((s = in2.readline())!= null) System.out.println(s); 13-(36/52)

37 使用压缩类的方法非常简单 : 只要将输出流包裹到 GZIPOutputStream 或 ZipOutputStream 之 中即可 剩下的只是普通的 I/O 操作 在本例中, 我们故意将面向字节或面向字符的方式混 合在了一起 10. 对象串行化 Java 的对象串行化将任何实现了 Serializable 接口的对象转换为一组字节, 而反过来, 又可以 用这组字节重新构成这个对象 将对象串行化之后, 我们获得的是一组字节, 可以随意处置 比如, 写入文件, 通过网络传 递给另一台电脑等等 串行化只保持对象的非静态成员变量, 而不保存任何成员方法或静态成员变量 如果一个对象实现了 Serializable 接口, 则串行化这个对象就非常简单 : 生成一个 OutputStream, 然后将这个 OutputStream 对象用 ObjectOutputstream 包裹, 调用 writeobject() 方法, 这个对象就被串行化, 并送到 OutputsStream 反串行化的过程很简单 : 用 ObjectInputStream 包裹一个 InputStream, 然后调用 readobject() 即可 串行化非常聪明的地方是, 它不仅保存了这个对象, 同时也保存了对象中引用到的别的所有 对象 下面的例子用互相连接的 虫子 对象作为测试对象, 演示了 Java 串行化的功能 // Lec13: Worm.java import java.io.*; import java.util.*; class Data implements Serializable { private int n; public Data(int n){ this.n = n; public String tostring(){ return Integer.toString(n); 13-(37/52)

38 public class Worm implements Serializable { private static Random rand = new Random(); private Data[] d = { new Data(rand.nextInt(10)), new Data(rand.nextInt(10)), new Data(rand.nextInt(10)), new Data(rand.nextInt(10)), new Data(rand.nextInt(10)), ; private Worm next; private char c; public Worm(int i, char x){ System.out.println("Constructing Worm, i = " + i + ", c = " + x); c = x; if(--i > 0) next = new Worm(i, (char)(x+1)); public String tostring(){ String s = ":" + c + "("; for(int i=0; i<d.length; i++) s += d[i]; s += ")"; if(next!= null) s += next; return s; // Lec13: Save.java import java.io.*; public class Save { static void usage(string s){ System.out.println( " 错误 : " + s + "\n" + " 正确用法 : Save filename\n"); System.exit(1); public static void main(string[] args) throws Exception { if(args.length!= 1) usage(" 没有参数!"); File file = new File(args[0]); File parent = file.getparentfile(); if(parent!= null &&!parent.exists()){ if(!parent.mkdir()) usage(" 无法生成文件 : " + parent); Worm w = new Worm(6, 'a'); ObjectOutputStream out = new ObjectOutputStream( new BufferedOutputStream( 13-(38/52)

39 new FileOutputStream(file))); String s = "Worm Storage"; out.writeobject(s); out.writeobject(w); System.out.println("Saved:"); System.out.println(s); System.out.println(w); out.close(); // Lec13: Restore.java import java.io.*; public class Restore { static void usage(){ System.out.println(" 用法 : java Restore filename\n"); System.exit(1); public static void main(string[] args) throws Exception { if(args.length!= 1) usage(); File file = new File(args[0]); if(!file.exists()) usage(); ObjectInputStream in = new ObjectInputStream( new BufferedInputStream( new FileInputStream(file))); System.out.println("Restored: "); while(true){ try{ System.out.println(in.readObject()); catch(ioexception e){ break; 为了使例子有趣,Worm 对象中包含了一个 Data 对象的数组, 其中每个元素都是随机产生的 每段 Worm 用一个字符标示, 在生成 Worm 时, 构造方法的第一个参数决定 Worm 的长度 在初始化数据成员 next 时, 用减了一的长度调用构造方法, 用 next=null 表示 worm 的结束 上面所有这些是为了使的对象 worm 足够复杂 对于这样一个复杂的对象, 如果由我们负责将其适当保存起来, 其复杂性是可想而知的 但是利用 Java 对象串形化, 事情就变得十分 13-(39/52)

40 简单, 我们只要调用 WriteObject() 方法即可 下面是一次执行产生的结果 >java Save invent\wormsave.dat Constructing Worm, i = 6, c = a Constructing Worm, i = 5, c = b Constructing Worm, i = 4, c = c Constructing Worm, i = 3, c = d Constructing Worm, i = 2, c = e Constructing Worm, i = 1, c = f Saved: Worm Storage :a(42944):b(38473):c(15549):d(22818):e(52299):f(17186) >java Restore invent\wormsave.dat Restored: Worm Storage :a(42944):b(38473):c(15549):d(22818):e(52299):f(17186) 从结果可以看出, 在执行 Restore 时, 并没有调用 worm 的构造方法, 整个对象是直接从 InputeStream 中获得的数据恢复而来的 对象串行化是面向字节的, 所以使用的是 InputStream 和 OutputStream 体系 恢复对象 那么, 如果在解串过程中不使用构造方法, 我们必须知道什么才能正确恢复一个对象呢? 比如, 如果我们串行化一个对象, 然后将结果通过网络传送给另外一台计算机, 那台机器能否仅靠这个串行化的数据重新这个对象呢? 为了回答这个问题, 我们将 Restore.class 文件拷贝到 invent 文件夹, 然后执行 > java Restore WormSave.dat 这时, 程序只能读出 String 对象, 接着就产生一个 ClassNotFoundException 异常, 表示它无 法恢复读到的对象 : Restored: Worm Storage java.lang.classnotfoundexception: Worm at java.net.urlclassloader$1.run(unknown Source) at java.security.accesscontroller.doprivileged(native Method) at java.net.urlclassloader.findclass(unknown Source) at java.lang.classloader.loadclass(unknown Source) 13-(40/52)

41 at sun.misc.launcher$appclassloader.loadclass(unknown Source) at java.lang.classloader.loadclass(unknown Source) at java.lang.classloader.loadclassinternal(unknown Source) at java.lang.class.forname0(native Method) at java.lang.class.forname(unknown Source) at java.io.objectinputstream.resolveclass(unknown Source) at java.io.objectinputstream.readnonproxydesc(unknown Source) at java.io.objectinputstream.readclassdesc(unknown Source) at java.io.objectinputstream.readordinaryobject(unknown Source) at java.io.objectinputstream.readobject0(unknown Source) at java.io.objectinputstream.readobject(unknown Source) at Restore.main(Restore.java:21) 如果我们再将 Worm.class 文件和 Data.class 文件复制到 invent 文件夹, 然后在此文件夹下执 行 > java Restore WormSave.dat 我们看到 worm 对象也被正常恢复了 由此可见, 能够恢复对象的先决条件是 JVM 必须能够 找到相关类的.class 文件 11. 正则表达式 Java1.4 中增加正则表达式的处理能力 什么是正则表达式? 正则表达式是字符串处理工具, 常见于 Unix 应用程序如 sed,awk 等 正则表达式允许我们在程序中指定字符串的样式, 按这些样式去匹配, 进行适当的处理 生成正则表达式 我们首先介绍一些常用的正则表达式构件 可从 java.util.regex.pattern 的文档中找到全部的构件 Summary of regular-expression constructs Construct Matches Characters x The character x 13-(41/52)

42 \\ The backslash character \0n The character with octal value 0n (0 <= n <= 7) \0nn The character with octal value 0nn (0 <= n <= 7) \0mnn The character with octal value 0mnn (0 <= m <= 3, 0 <= n <= 7) \xhh The character with hexadecimal value 0xhh \uhhhh The character with hexadecimal value 0xhhhh \t The tab character ('\u0009') \n The newline (line feed) character ('\u000a') \r The carriage-return character ('\u000d') \f The form-feed character ('\u000c') \a The alert (bell) character ('\u0007') \e The escape character ('\u001b') \cx The control character corresponding to x Character classes [abc] [^abc] [a-za-z] [a-d[m-p]] [a-z&&[def]] [a-z&&[^bc]] [a-z&&[^m-p]] a, b, or c (simple class) Any character except a, b, or c (negation) a through z or A through Z, inclusive (range) a through d, or m through p: [a-dm-p] (union) d, e, or f (intersection) a through z, except for b and c: [ad-z] (subtraction) a through z, and not m through p: [a-lq-z](subtraction) Predefined character classes. Any character (may or may not match line terminators) \d A digit: [0-9] \D A non-digit: [^0-9] \s A whitespace character: [ \t\n\x0b\f\r] \S A non-whitespace character: [^\s] \w A word character: [a-za-z_0-9] \W A non-word character: [^\w] POSIX character classes (US-ASCII only) \p{lower A lower-case alphabetic character: [a-z] \p{upper An upper-case alphabetic character:[a-z] \p{ascii All ASCII:[\x00-\x7F] \p{alpha An alphabetic character:[\p{lower\p{upper] \p{digit A decimal digit: [0-9] 13-(42/52)

43 \p{alnum \p{punct \p{graph \p{print \p{blank \p{cntrl \p{xdigit \p{space An alphanumeric character:[\p{alpha\p{digit] Punctuation: One ~ A visible character: [\p{alnum\p{punct] A printable character: [\p{graph\x20] A space or a tab: [ \t] A control character: [\x00-\x1f\x7f] A hexadecimal digit: [0-9a-fA-F] A whitespace character: [ \t\n\x0b\f\r] java.lang.character classes (simple java character type) \p{javalowercase Equivalent to java.lang.character.islowercase() \p{javauppercase Equivalent to java.lang.character.isuppercase() \p{javawhitespace Equivalent to java.lang.character.iswhitespace() \p{javamirrored Equivalent to java.lang.character.ismirrored() Classes for Unicode blocks and categories \p{ingreek A character in the Greek block (simple block) \p{lu An uppercase letter (simple category) \p{sc A currency symbol \P{InGreek Any character except one in the Greek block (negation) [\p{l&&[^\p{lu]] Any letter except an uppercase letter (subtraction) Boundary matchers ^ The beginning of a line $ The end of a line \b A word boundary \B A non-word boundary \A The beginning of the input \G The end of the previous match \Z The end of the input but for the final terminator, if any \z The end of the input Greedy quantifiers( 贪婪的, 贪心的 ) X? X, once or not at all X* X, zero or more times X+ X, one or more times X{n X, exactly n times X{n, X, at least n times 13-(43/52)

44 X{n,m X, at least n but not more than m times Reluctant quantifiers( 懒惰的 ) X?? X, once or not at all X*? X, zero or more times X+? X, one or more times X{n? X, exactly n times X{n,? X, at least n times X{n,m? X, at least n but not more than m times Possessive quantifiers( 有占有欲的 ) X?+ X, once or not at all X*+ X, zero or more times X++ X, one or more times X{n+ X, exactly n times X{n,+ X, at least n times X{n,m+ X, at least n but not more than m times Logical operators XY X Y (X) X followed by Y Either X or Y X, as a capturing group Back references \n Whatever the n th capturing group matched Quotation \ Nothing, but quotes the following character \Q Nothing, but quotes all characters until \E \E Nothing, but ends quoting started by \Q Special constructs (non-capturing) (?:X) X, as a non-capturing group (?idmsux-idmsux) Nothing, but turns match flags on - off (?idmsux-idmsux:x) X, as a non-capturing group with the given flags on - off (?=X) X, via zero-width positive lookahead (?!X) X, via zero-width negative lookahead (?<=X) X, via zero-width positive lookbehind 13-(44/52)

45 (?<!X) (?>X) X, via zero-width negative lookbehind X, as an independent, non-capturing group Pattern 和 Matcher 下面的例子可以作为对正则表达式的测试程序, 第一个参数是字符串, 后面的参数则是正则 表达式 // Lec13: TestRegularExpression.java import java.util.regex.*; public class TestRegularExpression { public static void main(string[] args){ if(args.length < 2){ System.out.println( " 用法 : TestRegularExpression 字符串正则表达式 "); System.exit(0); System.out.println("Input:\"" + args[0] + "\""); for(int i=1; i<args.length; i++){ System.out.println("\nRegular expression: \"" + args[i] + "\""); Pattern p = Pattern.compile(args[i]); Matcher m = p.matcher(args[0]); while(m.find()){ System.out.println("Match \"" + m.group() + "\" at position " + m.start() + "-" + (m.end()-1)); 按下列命令运行程序 : > java TestRegularExpression All happy families are all alike \w+\s 程序运行显示 : Input:"All happy families are all alike" Regular expression: "\w+\s" Match "All " at position 0-3 Match "happy " at position 4-9 Match "families " at position Match "are " at position Match "all " at position (45/52)

46 Java 利用 Pattern 和 Matcher 两个类实现正则表达式的功能 Pattern 是经过编译的正则表达式, 静态方法 Pattern.compile() 将一个正则表达式编译生成一个 Pattern 对象 正如上述例子中所示, 我们 Pattern 对象的 matcher() 方法以及输入字符串, 生成一个 Matcher 对象 Pattern 也有一个 static boolean matcher(string regex, charsequence input) 方法, 用于快速查阅 regex 可否能在 input 中找到, 另有一个 split() 方法, 该方法生成由于匹 配 regex 而将输入字符串分解而成的字符串数组 其中数组元素是在原输入字符串中提取匹 配字符串后所剩下的字符串 程序中通过给 Pattern.matcher() 方法传递输入字符串, 而获得 Matcher 对象 我们利用 Matcher 对象来访问结果 Matcher 提供如下方法 boolean matcher() boolean lookingat() boolean find() boolean find(int start) 当正则表达式 Pattern 与整个输入字符串相匹配, 则 matcher() 返回 true 如果输入字符串从头开始是一个匹配时,lookingAt() 返回 true find() Matcher.find() 可用于找到多个匹配 find() 方法就像一个迭代器, 能够遍历整个输入字符串 find() 的另一个版本则接受一个整数, 用这个整数指定在输入串中开始匹配的位置 Pattern 标志选项 Pattern.compile() 方法的另一个版本接受不同的标志选项, 改变正则表达式匹配的行为 : Pattern Pattern.compile(String input, int flag) 其中 flag 可能的取值由 Pattern 的如下常量给出 : 13-(46/52)

47 Compile 标志 CANON_EQ CASE_INSENSITIVE COUMENTS DOTALL MULTILINE UNICODE_CASE UNIX_LINES 效果只有两个字符的正规分解相匹配时, 这两个字符才相配 缺省情况下,CASE_INSENSITIVE 模式下处理的输入字串是 ASCII 串 该标志允许我们不分大小写匹配在这个模式下, 空格被忽视, 嵌入的以 # 开始的注释行也被忽视在 DOTALL 模式下, 表达式. 与任何字符相匹配, 包括行的结束符 而缺省模式下,. 与行的结束符不匹配在多行模式下, 表达式 ^ 和 $ 分别表示行的开始和结束, ^ 同时也可与输入串的开始匹配, $ 与输入串的结束相匹配 在缺省模式下, ^ 和 $ 只与整个输入串的开始和结束相匹配指定这个标志后, 不分大小写 匹配是在 Unicode 基础上进行的在这个模式下, 只有 \n 行结束串符能被. 以及 ^ 识别 split() split() 方法从输入串中将与正则表达式相匹配的字符提取之后, 用剩余的字符串形成 String 数组 // Lec13:regex: SplitDemo.java import java.util.arrays; import java.util.regex.pattern; public class SplitDemo { public static void main(string[] args) { String input = "This!!unusual use!!of exclamation!!points"; System.out.println(Arrays.asList( Pattern.compile("!!").split(input))); // Only do the first three: System.out.println(Arrays.asList( Pattern.compile("!!").split(input, 3))); System.out.println(Arrays.asList( "Aha! String has a split() built in!".split(" "))); 该程序在运行时显示 : [This, unusual use, of exclamation, points] 13-(47/52)

48 [This, unusual use, of exclamation!!points] [Aha!, String, has, a, split(), built, in!] 第二个 splite() 限制了分解的次数 正规表达式非常有用, 所以有些功能已直接实现在 String 类中, 比如 splite() matches() replacefirst() replaceall() 等 替换操作 在寻找并替换字符串时, 正规表达式格外有用 我们常用的替换方法有 : replacefirst(string replacement) 用 replacement 替换输入串中的第一个匹配的部分 replaceall(string replacement) 用 replacement 替换输入串中的每个匹配的部分 AppendReplacement(StringBuffer sbuf, String replacement) 按步骤替换并写入 sbuf 中 appendtail(stringbuffer sbuf, String replacement) 下面的例子显示了各种替换操作的用法 程序首先利用正规表达式将文件中的注释块提取出 来, 用作程序其余部分的输入串 import java.io.file; // Lec13:regex: TheReplacements.java import java.util.regex.matcher; import java.util.regex.pattern; import net.effortech.harry.util.textfile; /*! Here's a block of text to use as input to the regular expression matcher. Note that we'll first extract the block of text by looking for the special delimiters, then process the extracted block.!*/ public class TheReplacements { public static void main(string[] args) throws Exception { String s = TextFile.read(new File("regex\\TheReplacements.java")); 13-(48/52)

49 // Match the specially-commented block of text above: Matcher minput = Pattern.compile("/\\*!(.*)!\\*/", Pattern.DOTALL). matcher(s); if(minput.find()) s = minput.group(1); // Captured by parentheses // Replace two or more spaces with a single space: s = s.replaceall(" {2,", " "); // Replace one or more spaces at the beginning of each // line with no spaces. Must enable MULTILINE mode: s = s.replaceall("(?m)^ +", ""); System.out.println(s); s = s.replacefirst("[aeiou]", "(VOWEL1)"); StringBuffer sbuf = new StringBuffer(); Pattern p = Pattern.compile("[aeiou]"); Matcher m = p.matcher(s); // Process the find information as you // perform the replacements: while(m.find()) m.appendreplacement(sbuf, m.group().touppercase()); // Put in the remainder of the text: m.appendtail(sbuf); System.out.println(sbuf); 程序运行时显示 : Here's a block of text to use as input to the regular expression matcher. Note that we'll first extract the block of text by looking for the special delimiters, then process the extracted block. H(VOWEL1)rE's A block Of text to UsE As InpUt to the regular ExprEssIOn matcher. NOtE that we'll first ExtrAct the block Of text by looking for the special delimiters, then process the ExtrActEd block. 1) 我们用 TextFile.read() 将 Replacments.java 文件的内容内读入到 String 对象之中, 用作程序中其它地方的输入串 2) minput 是一个用正则表达式 /\\*!(.*)!\\*/" 生成的匹配器 这个正则表达式代表了以 /*!" 开头, 以!*/" 结束的任何字符串, 所以当 s 作为输入串匹配时, 我们就获得了程序中位于 /*!" 和!*/" 之间的文字 13-(49/52)

50 3) 我们利用 String.replacAll() 方法, 将两个以上空格替换为单个空格 4) 利用 String.replacAll() 方法, 删除每行开头的空格 5) 利用 String.replacFirst() 方法, 将第一个元音字母替换为 (VOWEL1) 6) 利用 matcher.appendreplacement() 将所有的元音字母替换为对应的大写字母 正规表达式与 JavaI/O 目前为止的所有例子中, 正规表达式都用于静态字符串, 下面的例子显示了将正规表达式用 于文件匹配的方法 Grep.java 接受两个参数, 其中第一个是文件名称, 第二个是需要查找的 正规表达式 程序作为输出, 显示匹配文字串的行以及匹配的位置 // Lec13: Grep.java import java.io.*; import java.util.regex.*; import java.util.*; import net.effortech.harry.util.*; public class Grep { public static void main(string[] args) throws Exception { if(args.length!= 2){ System.out.println("Usage: java Grep file regex"); System.exit(1); Pattern p = Pattern.compile(args[1]); ListIterator it = Arrays.asList( TextFile.read( new File(args[0])).split("\n")).listIterator(); while(it.hasnext()){ String s = (String)it.next(); Matcher m = p.matcher(s); while(m.find()) System.out.println(it.nextIndex() + ": " + m.group() + " + m.start() + "-" + (m.end()-1)); 我们用 TextFile.read() 方法读入文件, 并用 String.split() 方法按 \n 将整个文字内容分解为字 13-(50/52)

51 符串数组, 然后转换为 ArrayList. 我们用 ListIterator 遍布整个 ArrayList, 其中每一项对应文件中的行 对应于每一行, 我们利用 Patternmatcher() 生成一个匹配器, 然后用 find() 寻找匹配 执行下列命令, > java Grep regex\thereplecements.java \w{8,+\. 时, 显示如下结果 : 2: : : : StringTokenizer 还有用吗? 在 java 1.4 之前, 我们利用 StringTokenizer 类来分解字符串 但是, 在介绍了正则表达式之 后, 实际上利用正则表达式分解字符串更加简明 方便 : // Lec13:regex: ReplacingStringTokenizer.java import java.util.*; public class ReplacingStringTokenizer { public static void main(string[] args){ String input = "All happy families are alike, but an " + "unhappy family is unhappy after its own fashion."; StringTokenizer stoke = new StringTokenizer(input); System.out.println("\nStringTokenizer:"); while(stoke.hasmoreelements()) System.out.println(stoke.nextToken()); System.out.println("\nregular expression: "); System.out.println(Arrays.asList(input.split("[\\s.,]+"))); 该程序运行时显示 : StringTokenizer: All happy families 13-(51/52)

52 are alike, but an unhappy family is unhappy after its own fashion. regular expression: [All, happy, families, are, alike, but, an, unhappy, family, is, unhappy, after, its, own, fashion] 利用正规表达式, 我们还可以按非常复杂的方式分解字符串, 而用 StringTokenizer 分解的方 式就受到极大的限制 13-(52/52)