认识达内从这里开始

认真做教育专心促就业

好好熟知Java I/O

发布：达内培训
来源：互联网
时间：2018-05-14 17:32

    该文中的内容来源于 Oracle 的官方文档。Oracle 在 Java 方面的文档是非常完善的。这一篇主要讲 Java 中的 I/O
    前言
    不知道大家看到这个标题会不会笑我，一个使用 Java 多年的老程序员居然一直没有记住 Java 中的 I/O.不过说实话，Java 中的 I/O 确实含有太多的类、接口和抽象类，而每个类又有好几种不同的构造函数，而且在 Java 的 I/O 中又广泛使用了 Decorator 设计模式（装饰者模式）。总之，即使是在 OO 领域浸淫多年的老手，看到下面这样的调用一样会蛋疼：
    BufferedReader reader = new BufferedReader（new InputStreamReader（new FileInputStream（“somefile.txt”）））；
    当然，这仅仅只是我为了体现 Java I/O 的错综复杂的构造函数而虚构出来的一个例子，现实中创建一个 BufferedReader 很少会嵌套这么深，因为可以直接使用 FileReader 而避免多创建一个 FileInputStream.但是从一个 InputStream 转化成一个 BufferedReader 总是有那么几步路要走的，比如下面这个例子：
    URL cnblogs = new URL（“#/”）；BufferedReader reader = new BufferedReader（new InputStreamReader（cnblogs.openStream（）））；
    Java I/O 涉及到的类也确实特别多，不仅有分别用于操作字符流和字节流的 InputStream 和 Reader、OutputStream 和 Writer,还有什么 BufferedInputStream、BufferedReader、PrintWriter、PrintStream等，还有用于沟通字节流和字符流的桥梁 InputStreamReader 和 OutputStreamWriter,每一个类都有其不同的应用场景，如此细致的划分，光是名字就足够让人晕头转向了。
    我一直记不住 Java I/O 中各种细节的另一个原因可能是我深受 ANSI C 的荼毒吧。在 C 语言的标准库中，将文件的打开方式分为两种，一种是将文件当成二进制格式打开，一种是当成文本格式打开。这和 Java 中的字节流和字符流的划分有相似之处，但却掩盖了所有的数据其实都是字节流这样的本质。ANSI C 用多了，总以为二进制格式和文本格式是同一个层面的两种对立面，只能对立而不能统一，却不知在 Java 中，字符流是对字节流的更高层次的封装，最底层的 I/O 都是建立在字节流的基础上的。如果抛开 ANSI C 语言的标准 I/O 库，直接考察操作系统层面的 POSIX I/O,会发现操作的一切都是原始的字节数据，根本没有什么字节字符的区别。
    除此之外，Java 走得更远，它考虑到了各种更加广泛的字节流，而不仅仅限于文件。比如网络中传输的数据、内存中传输的对象等等，都可以用流来抽象。但是不同的流具有不同的特性，有的流可以随机访问，而有的却只能顺序访问，有的可以解释为字符，有的不能。在能解释为字符的流中，有的一次只能访问一个字符，有的却可以一次访问一行，而且把字节流解释成字符流，还要考虑到字符编码的问题。
    以上种种，均是造成 Java I/O 中类和接口多、对象构造方式复杂的原因。
    从对立到统一，字节流和字符流
    先来说对立。在 Java 中如果要把流中的数据按字节来访问，就应该使用 InputStream 和 OutputStream,如果要把流中的数据按字符来访问，就应该使用 Reader 和 Writer.上面提到的这四个类都是抽象类，是所有其它具体类的基础。不能直接构造 InputStream、OutputStream、Reader 和 Writer 类的实例，但是根据 OO 原则，可以这样用：
    InputStream in = new FileInputStream（“somefile”）；int c = in.read（）；
    或者这样：
    Reader reader = new FileReader（“somefile”）；int c = reader.read（）；
    这里的 FileInputStream 和 FileReader 就是具体的类，这样的类还有很多，都位于 java.io 包中。文件读写是我们最常用的操作，所以最常用的就是 FileInputStream、FileOutputStream、FileReader、FileWriter这四个。这几个类的构造函数有多个，但是最简单的，肯定是接受一个代表文件路径的字符串做参数的那一个。根据 OO 原则，我们一般使用更加抽象的 InputStream、OutputStream、Reader、Writer 来引用具体的对象。所以，在考察 API 的时候，只需要考察这四个抽象类就可以了，其它的具体类，基本上只需要考察它们的构造方式。
    而这几个类的 API 也确实很好记，用来输入的两个类 InputStream 和 Reader 主要定义了read（）方法，而用来输出的两个类 OutputStream 和 Writer 主要定义了write（）方法。所不同者，前者操作的是字节，后者操作的是字符。read（）和write（）最简单的用法是这样的：
    package com.xkland.sample;import java.io.InputStream;import java.io.FileInputStream;import java.io.IOException;import java.io.FileNotFoundException;public class JavaIODemo { public static void main（String[] args） { if（args.length < 1）{ System.out.println（“Usage: JavaIODemo filename”）； return; } String somefile = args[0]; InputStream in = null; try{ in = new FileInputStream（somefile）； int c; while（（c = in.read（）） != -1） { //这里用到read（） System.out.write（c）； //这里用到write（） } }catch（FileNotFoundException e）{ System.out.println（“File not found.”）； }catch（IOException e）{ System.out.println（“I/O failed.”）； }finally{ if（in != null）{ try { in.close（）； }catch（IOException e）{ //关闭流时产生的异常，直接抛弃 } } } }}

上面的例子展示了read（）和write（）的用法，在 InputStream 和 OutputStream 中，这两个方法操作的都是字节，但是，这里用来保存这个字节的变量却是int类型的。这正是 API 设计的匠心所在，因为int的宽度明显比byte要大，所以将一个byte读入到一个int之后，有效的数据只占据int型变量的最低8位，如果read（）方法返回的是有效数据，那么这个int型的变量永远都不可能是负数。在这种情况下，read（）方法可以用返回负数的方式来表示碰到特殊情况，比如返回-1表示到达了流的末尾，也就是用-1代表EOF.write（）方法接受的参数也是int型的，但是它只把这个int型变量的最低8位写入流，其余的数据被忽略。

潍坊培训学校

    上面的例子还展示了 Java I/O 的一些特征：
    InputStream、OutputStream、Reader、Writer 等资源用完之后要关闭；
    所有的 I/O 操作都可能产生异常，包括调用close（）方法。
    这两个特征搅到一起就比较复杂了，本来因为异常的产生就容易让流的close（）语句执行不到，所以只有把close（）写到finally块中，但是在finally块中调用close（）又要写一层try…catch…代码块。如果同时有多个流需要关闭，而前面的close（）抛出异常，则后面的close（）将不会执行，极易发生资源泄露。再加上如果前面的catch（）块中的异常被重新抛出，而finally块中又没有处理好异常的话，前面的异常会被抑制，所以大部分人都 hold 不住这样的代码，包括 Oracle 的官方教程中的写法都是错误的。下面来看一下 Oracle 官方教程中的例子：
    import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;public class CopyBytes { public static void main（String[] args） throws IOException { FileInputStream in = null; FileOutputStream out = null; try { in = new FileInputStream（“xanadu.txt”）； out = new FileOutputStream（“outagain.txt”）； int c; while （（c = in.read（）） != -1） { out.write（c）； } } finally { if （in != null） { in.close（）； } if （out != null） { out.close（）； } } }}
    官方教程写得比我更偷懒，它直接让main（）方法抛出IOException而避免了异常处理，也避免了在finally块中的close（）语句外再写一层try…catch…但是，这个示例的漏洞有两个，其一是如果in.close（）抛出了异常，则out.close（）就不会执行；其二是如果try块中抛出了异常，finally块中又抛出了异常，则前面抛出的异常会被丢弃。为了解决这个问题，Java 7中新加入了try-with-resource语法。后面都用这种方式写代码。
    很显然，一次处理一个字节效率是及其低下的，所以read（）和write（）还有别的重载版本：
    int read（byte[] b）int read（byte[] b, int off, int len）void write（byte[] b）void write（byte[] b, int off, int len）
    它们都可以一次操作一块数据，用字节数组做为存储数据的容器。read（）返回的是实际读取的字节数。而对于 Reader 和 Writer,它们的read（）和write（）方法的定义是这样的：
    int read（）int read（char[] cbuf）int read（char[] cbuf, int off, int len）void write（int c）void write（char[] cbuf）void write（char[] cbuf, int off, int len）void write（String str）void write（String str, int off, int len）
    可以看出，使用 Reader 和 Writer 一次操作一个字符的时候，依然使用的是int型的变量。如果一次操作一块数据，则使用字符数组。输出的时候，还可以直接使用字符串。
    到这里，已经可以很轻易记住八个类了：InputStream、OutputStream、Reader、Writer、FileInputStream、FileOutputStream、FileReader、FileWriter.前四个是抽象类，后四个是操作文件的具体类。而且这八个类分成两组，一组操作字节流，一组操作字符流。很简单的对立分组。
    然而，前面我提到过，其实字节流和字符流并不是完全对立的存在，其实字符流是在字节流上更高层次的封装。在底层，一切数据都是字节，但是经过适当的封装，可以把这些字节解释成字符。而且，并不是所有的 Reader 都是可以像 FileReader 那样直接创建的，有时，只能拿到一个可以读取字节数据的 InputStream,却需要在它之上封装出一个 Reader,以方便按字符的方式读取数据。最典型的例子就是可以这样访问一个网页：
    URL cnblogs = new URL（“#/”）；InputStream in = cnblogs.openStream（）；
    这时，拿到的是字节流 InputStream,如果想获得按字符读取数据的 Reader,可以这样创建：
    Reader reader = new InputStreamReader（in）；
    所以， InputStreamReader 是沟通字节流和字符流的桥梁。同样的桥梁还用用于输出的 OutputStreamWriter.至此，不仅又轻松地记住了两个类，也再次证明了字节流和字符流既对立又统一的辩证关系。
    从抽象到具体，数据的来源和目的
    InputStream、OutputStream、Reader 和 Writer 是抽象的，根据不同的数据来源和目的又有不同的具体类。前面的例子中提到了基于 File 的流，也初步展示了一个基于网络的流。结合平时使用计算机的经验，我们也可以想到其它一些不同的数据来源和目的，比如从内存中读取字节或把字节写入内存，从字符串中读取字符或者把字符写入字符串等等，还有从管道中读取数据和向管道中写入数据等等。根据不同的数据来源和目的，可以有这样一些具体类：FileInputStream、ByteArrayInputStream、PipedInputStream、FileOutputStream、ByteArrayOutputStream、PipedOutputStream、FileReader、StringReader、CharArrayReader、PipedReader、FileWriter、StringWriter、CharArrayWriter、PipedWriter等。从这些类的命名可以看出，凡是以Stream结尾的，都是操作字节的流，凡是以 Reader 和 Writer 结尾的，都是操作字符的流。只有 InputStreamReader 和 OutputStreamWriter 是例外，它是沟通字节和字符的桥梁。对于这些具体类，使用起来是没有什么困难的，只需要考察它们的构造函数就可以了。
    从简单到丰富，使用 Decorator 模式扩展功能
    从前文可以看出，所有的流都支持read（）和write（），但是这样的功能毕竟还是太简单，有时还需要更高层次的功能需求，所以需要使用 Decorator 模式来对流进行扩展。比如，一次操作一个字节或一个字符效率太低，想把数据先缓存在内存中再进行操作，就可以扩展出 BufferedInputStream、BufferedReader、BufferedOutputStream、BufferedWriter 类。可以猜测到，BufferedOutputStream 和 BufferedWriter 类中一定有一个flush（）方法，用来把缓存的数据写入到流中。而且，BufferedReader 还有 readLine（）方法，可以一次读取一行字符，甚至可以再扩展出一个 LineNumberReader,还可以提供行号的支持。再比如，有时从流中读出一个字节或一个字符后，又不想要了，想把它还回去，就可以再扩展出 PushbackInputStream 和 PushbackReader,提供unread（）方法将刚读取的字节或字符还回去。可以想象，这种还回去的功能应该是需要缓存功能支持的，所以它们应该是在 BufferedInputStream 和 BufferedReader 外面又加了一层的装饰。这就是 Decorator 模式。

Java I/O 中自带的这种扩展类还有很多，不容易记。后面的介绍中，会针对重要的类举几个例子。在此之前，还是通过 UML 类图来了解一下扩展类。

以上就是潍坊培训学校给大家做的内容详解，更多关于java课程的学习，请继续关注潍坊培训学校。

< 上一篇：JAVA程序员15个学习习惯

下一篇：Java常用类之String >