心得---字符流、缓冲流、装饰模式 - CSDN博客
1.&&& Reader类和Writer类用来专门处理字符流。这两个类都是抽象类，从他们派生出了许多子类，增强功能、提高效率，实现各种不同要求的字符输入/输出流的处理。
&&&& IO体系中的子类名后缀都是父类名称，而前缀都是体现子类功能的名字。字符流用于存储和检索文本。两者的使用方法与InputStream类和OutputStream类基本相同，不同的是，这两个类以Unicode字符为单位进行读写，当写入一个16 位的Unicode字符时，按字节分成两部分，先写高位字节，后写低位字节。
&&&& 对于读取或者写入流对象的构造函数，以及读写方法，还有刷新关闭功能都会抛出IOException或其子类，所以都要进行处理。
抽象类java.io.Reader是所有字符输入流类型的父类，其中声明了用于读取字符流的有关方法，其类层次关系为：
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
3. Reader类中定义的方法
u&&&public int read()：读取一个字符，返回的是读到的那个字符。如果读到流的末尾，返回-1。
u&&&public int read(char[] cbuf)：将读到的字符存入指定的数组中，返回的是实际读取的字符数。如果读到流的末尾，返回-1。
u&&&public abstract int read(char[]cbuf,int off,int len)：将读到的字符存入数组的指定位置（off），每次最多读len个字符，返回实际读取的字符数。如果读到流的末尾，返回-1。
u&&&close()：读取字符其实用的是window系统的功能，使用完毕后，进行资源的释放。
Java.io.Writer与java.io.Reader类对应，是所有字符输出流类型的共同父类，也是一个抽象类，其中声明了用于写字符流的有关方法。
5. Writer类中定义的主要方法
u&&&public void write(int c)：将一个字符写入到流中。
u&&&public void write(char[])：将数组中的字符依次写出。
u&&&public abstract void write(char[]bcbuf,int off,int len)：将数组中下标off开始的len个字符写出。
u&&&public void write(String)：将一个字符串写入到流中。
u&&&public abstract void flush()：刷新流，将流中的数据刷新到目的地中，流还存在。Reader类中没有该方法。
u&&&public abstreact void close()：关闭资源，关闭前会先调用flush，刷新流中的数据去目的地，然后流关闭。
6. FileWriter的使用
u&&&该类没有特有的方法。只有自己的构造函数。
u&&&该类特点：
?&&&用于处理文本文件。
?&&&该类中有默认的编码表，
?&&&该类中有临时缓冲。
u&&&构造函数
?&&&public FileWriter(String filename);//调用系统资源，在指定位置，创建一个文件。注意：如果该文件已存在，将会被覆盖。
?&&&public FileWriter(Stringfilename,boolean append);//当传入的boolean类型的参数值为true时，会在指定文件末尾处进行数据的续写。
7.完整的异常处理方式：例：
class Demo{
&&&& public staticvoid main(String[] args)throws IOException{
&&&&&&& FileWriterfw =
&&&&&&& try{
&&&&&&&&& fw = newFileWriter(&z:\\demo.txt&);
&&&&&&&&& fw.write(&abcdec&);
&&&&&&&&& fw.flush();
&&&&&&&&& fw.write(&kkkk&);
&&&& }catch(IOExceptione){
&&&&&&& System.out.println(e.toString());
&&&& }finally{
&&&&&&& if(fw!=null)
&&&&&&&&& try{
&&&&&&&&&&&& fw.close();&
&&&&&&&&& }catch(IOExceptione){
&&&&&&&&& && System.out.println(&close:&+e.toString());
&&&&&&&&& }&
8.当指定绝对路径时，定义目录分隔符有两种方式：
o&&&&&& 反斜线但是一定要写两个。\\ new FileWriter(&c:\\demo.txt&);（否则会默认为转义字符，第一个为转义字符）
o&&&&&& 斜线& /& 写一个即可。 new FileWriter(&c:/demo.txt&);
9. FileReader的使用
o&&&&&& 用于读取文本文件的流对象。
o&&&&&& 构造函数：在读取流对象初始化的时候，必须要指定一个被读取的文件。
public FileReader(String filename);//如果该文件不存在会发生FileNotFoundException
注意：read方法若返回-1，则表明当前读取位置已经到达流的末尾。例如（读取文件的全部内容）：int ch = 0；
while((ch=fr.read())!=-1){
&&&&&& //数据处理(char)ch
10. 缓冲的字符流BufferedReader/BufferedWriter
u&&&采用缓冲处理是为了提高效率，如果没有缓存，例如FileReader对象，每次调用read()方法进行读操作时，都会直接去文件中读取字节，转换成字符并返回，这样频繁的读取文件效率很低。
u&&&缓冲的字符流的出现提高了对流的操作效率，原理就是将数组进行封装。
u&&&在使用缓冲的字符流对象时，缓冲的存在是为了增强流的功能，因此在建立缓冲的字符流对象时，要先有流对象的存在。
public (&in) ;
public (&in, int&sz) :创建一个使用制定大小输入缓冲区的缓冲字符输入流，sz指输入缓冲区的大小，如果sz&=0,则抛出IllegalArgumentException异常。
public (&out) ;
public (&out, int&sz);
u&&&BufferedReader的特有方法：public String readLine();//一次读一行，到行标记时，将行标记之前的字符数据作为字符串返回。当读到末尾时，返回null。
u&&&BufferedWriter的特有方法：public void newLine();//写出平台相关的行分隔符来标记一行的终止。Windows平台下为’\n’。
使用缓冲的字符流时其实就是使用流对象的方法，只不过加入了数组，对数据进行了临时存储，为了提高操作数据的效率。
方法readLine()的原理：该方法用的还是与缓冲的字符流相关联的流对象的read()方法，只不过，每一次读到一个字符，先不进行具体操作，先进行临时存储，当读取到回车标记时，将临时容器中存储的数据一次性返回。
注意，它的出现是基于流并增强了流的功能。这也是一种设计模式的体现：装饰设计模式，对一组对象进行功能的增强。
11. 装饰设计模式比继承有更好的灵活性
需求：想要对数据的操作提高效率，就用到了缓冲技术。
方法：通过所学的继承特性，可以建立MediaWriter类的子类和TextWriter类的子类，在子类中重写父类的write方法即可
问题：当Writer中子类对象过多，那么为了提高每一个对象效率，每一个对象都有 一个自己的子类Buffered。虽然可以实现，但是继承体系变的很臃肿。那么是否可以对其进行优化呢？
解决方法：增加的这些子类都是在使用缓冲技术。可不可以对缓冲技术进行描述，将需要增强的对象传递给缓冲区即可。
classBufferdWriter{
&&&& BufferedWriter(MediaWritermw){}
&&&& BufferedWriter(TextWritermw){}
出现的新的问题：该类虽然完成对已有两个对象的增强。但是当有新的对象出现时，还要继续在该类中添加构造函数。这样不利于扩展和维护。
解决方法：将对这些对象父类型进行操作即可。这就是多态，提高了程序的扩展性。同时BufferedWriter中一样具体write方法，只不过是增强后的write。所以BuferedWriter也应该是Writer中的一个子类。
class BufferedWriter extends Writer{
&& private W
&& BufferedWriter(Writerw){
&&&& this.w =
结论：这样就会发现装饰设计模式，优化增强功能的部分。比继承要灵活很多。
装饰类和被装饰类都同属于一个父类或接口FilterReader (Java 2 Platform SE 6)
<META NAME="keywords" CONTENT="概述, JavaTM 2 Platform Standard Edition 6API 开发人员文档">
JavaTM&2&PlatformStandard&Ed. 6
类 FilterReader
java.io.FilterReader
所有已实现的接口： ,
直接已知子类：
public abstract class FilterReaderextends
用于读取已过滤的字符流的抽象类。抽象类 FilterReader 自身提供了一些将所有请求传递给所包含的流的默认方法。FilterReader 的子类应重写这些方法中的一些方法，并且还可以提供一些额外的方法和字段。
从以下版本开始：
protected &
&&&&&&&&&&底层字符输入流。
&&&&&&&&&&创建一个新的 filtered reader。
&&&&&&&&&&关闭该流并释放与之关联的所有资源。
(int&readAheadLimit)
&&&&&&&&&&在流中的当前位置上作标记。
&&&&&&&&&&判断此流是否支持 mark() 操作。
&&&&&&&&&&读取单个字符。
(char[]&cbuf,
&&&&&&&&&&将字符读入数组的某一部分。
&&&&&&&&&&判断此流是否已经准备好用于读取。
&&&&&&&&&&重置该流。
&&&&&&&&&&跳过某些字符。
, , , , , , , , , ,
底层字符输入流。
FilterReader
protected FilterReader(&in)
创建一个新的 filtered reader。
参数：in - 提供底层流的 Reader 对象。
- 如果 in 为 null
public int read()
读取单个字符。
返回：作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -1
- 如果发生 I/O 错误
public int read(char[]&cbuf,
将字符读入数组的某一部分。
指定者：类
参数：cbuf - 目标缓冲区off - 开始存储字符处的偏移量len - 要读取的最多字符数
返回：读取的字符数，如果已到达流的末尾，则返回 -1
- 如果发生 I/O 错误
public long skip(long&n)
跳过某些字符。
参数：n - 要跳过的字符数
返回：实际跳过的字符数
- 如果发生 I/O 错误
public boolean ready()
判断此流是否已经准备好用于读取。
返回：如果保证下一个 read() 不阻塞输入，则返回 True，否则返回 false。注意，返回 false 并不保证阻塞下一次读取。
- 如果发生 I/O 错误
markSupported
public boolean markSupported()
判断此流是否支持 mark() 操作。
返回：当且仅当此流支持此 mark 操作时，返回 true。
public void mark(int&readAheadLimit)
在流中的当前位置上作标记。
参数：readAheadLimit - 在仍保留该标记的情况下，对可读取字符数量的限制。在读取这样多的字符后，尝试重置流可能会失败。
- 如果发生 I/O 错误
public void reset()
重置该流。
- 如果发生 I/O 错误
public void close()
复制的描述
关闭该流并释放与之关联的所有资源。在关闭该流后，再调用 read()、ready()、mark()、reset() 或 skip() 将抛出 IOException。关闭以前关闭的流无效。
指定者：接口
中的 指定者：类
- 如果发生 I/O 错误
JavaTM&2&PlatformStandard&Ed. 6
版权所有 2008 Sun Microsystems, Inc. 保留所有权利。请遵守。& &&& Java中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。&
& &&& Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的便是块IO。
　　流IO的好处是简单易用，缺点是效率较低。块IO效率很高，但编程比较复杂。 & & & Java IO模型& : &&&&& Java的IO模型设计非常优秀，它使用Decorator模式，按功能划分Stream，您可以动态装配这些Stream，以便获得您需要的功能。例如，您需要一个具有缓冲的文件输入流，则应当组合使用FileInputStream和BufferedInputStream。
&&&&& &流是磁盘或其它外围设备中存储的数据的源点或终点。&
&&& 在电脑上的数据有三种存储方式，一种是外存，一种是内存，一种是缓存。比如电脑上的硬盘，磁盘，U盘等都是外存，在电脑上有内存条，缓存是在CPU里面的。外存的存储量最大，其次是内存，最后是缓存，但是外存的数据的读取最慢，其次是内存，缓存最快。这里总结从外存读取数据到内存以及将数据从内存写到外存中。对于内存和外存的理解，我们可以简单的理解为容器，即外存是一个容器，内存又是另外一个容器。那又怎样把放在外存这个容器内的数据读取到内存这个容器以及怎么把内存这个容器里的数据存到外存中呢？
&&&& 在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:
&&&&&&&& 标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流等等，java中将输入输出抽象称为流，就好像水管，将两个容器连接起来。将数据冲外存中读取到内存中的称为输入流，将数据从内存写入外存中的称为输出流。
&&& 流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。
&&&&& 总结的基本概念如下：
1) 数据流：
&&& 一组有序，有起点和终点的字节的数据序列。包括输入流和输出流。
2) 输入流（Input& Stream）：
&&&&& 程序从输入流读取数据源。数据源包括外界(键盘、文件、网络&)，即是将数据源读入到程序的通信通道
3) 输出流：
&&& 程序向输出流写入数据。将程序中的数据输出到外界（显示器、打印机、文件、网络&）的通信通道。
采用数据流的目的就是使得输出输入独立于设备。
Input Stream不关心数据源来自何种设备（键盘，文件，网络） Output Stream不关心数据的目的是何种设备（键盘，文件，网络）
4 数据流分类：
流序列中的数据既可以是未经加工的原始二进制数据，也可以是经一定编码处理后符合某种格式规定的特定数据。因此Java中的流分为两种：
1) 字节流：数据流中最小的数据单元是字节
2)& 字符流：数据流中最小的数据单元是字符， Java中的字符是Unicode编码，一个字符占用两个字节。
Java程序可通过命令行参数与外界进行简短的信息交换，同时，也规定了与标准输入、输出设备，如键盘、显示器进行信息交换的方式。而通过文件可以与外界进行任意数据形式的信息交换。
1. 命令行参数
public class TestArgs {&
&&& public static void main(String[] args) {&
&&&&&&& for (int i = 0; i & args. i++) {&
&&&&&&&&&&& System.out.println("args[" + i + "] is &" + args[i] + "&");&
&&&&&&& }&
public class TestArgs {
public static void main(String[] args) {
for (int i = 0; i & args. i++) {
System.out.println("args[" + i + "] is &" + args[i] + "&");
运行命令：java Java C VB
运行结果：
args[0] is &Java&
args[1] is &C&
args[2] is &VB&
2. 标准输入，输出数据流
java系统自带的标准数据流：java.lang.System:
java.lang.System&&
public final class System& extends Object{&&
&& static& PrintStream&
&& static& InputStream&
&& static& PrintStream&
java.lang.System
public final class System
extends Object{
PrintS//标准错误流（输出）
InputS//标准输入(键盘输入流)
PrintS//标准输出流(显示器输出流)
注意： （1）System类不能创建对象，只能直接使用它的三个静态成员。 （2）每当main方法被执行时,就自动生成上述三个对象。
标准输出流 System.out
System.out向标准输出设备输出数据，其数据类型为PrintStream。方法：
&&&&& Void print(参数)
&&&&& Void println(参数)
2)标准输入流 System.in
System.in读取标准输入设备数据（从标准输入获取数据，一般是键盘），其数 据类型为InputStream。方法：
&&&&&&& int read()& //返回ASCII码。若,返回值=-1，说明没有读取到任何字节读取工作结束。
&&&&&&&& int read(byte[]
b)//读入多个字节到缓冲区b中返回值是读入的字节数
import java.io.*;&
public class StandardInputOutput {&
&&& public static void main(String args[]) {&
&&&&&&& try {&
&&&&&&&&&&& System.out.println("please Input:");&
&&&&&&&&&&& while ((b = System.in.read()) != -1) {&
&&&&&&&&&&&&&&& System.out.print((char) b);&
&&&&&&&&&&& }&
&&&&&&& } catch (IOException e) {&
&&&&&&&&&&& System.out.println(e.toString());&
&&&&&&& }&
import java.io.*;
public class StandardInputOutput {
public static void main(String args[]) {
System.out.println("please Input:");
while ((b = System.in.read()) != -1) {
System.out.print((char) b);
} catch (IOException e) {
System.out.println(e.toString());
等待键盘输入，键盘输入什么，就打印出什么：
3)标准错误流
& System.err输出标准错误，其数据类型为PrintStream。可查阅API获得详细说明。
&&& 标准输出通过System.out调用println方法输出参数并换行，而print方法输出参数但不换行。println或print方法都通 过重载实现了输出基本数据类型的多个方法，包括输出参数类型为boolean、char、int、long、float和double。同时，也重载实现 了输出参数类型为char[]、String和Object的方法。其中，print（Object）和println（Object）方法在运行时将调 用参数Object的toString方法。
import java.io.BufferedR&
import java.io.IOE&
import java.io.InputStreamR&
public class StandardInputOutput {&
&&& public static void main(String args[]) {&
&&&&&&& S&
&&&&&&& InputStreamReader ir = new InputStreamReader(System.in);&
&&&&&&& BufferedReader in = new BufferedReader(ir);&
&&&&&&& System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出"&
&&&&&&&&&&&&&&& + "\nWindows系统: ctrl-z 退出");&
&&&&&&& try {&
&&&&&&&&&&&
&&&&&&&&&&& s = in.readLine();&
&&&&&&&&&&&
&&&&&&&&&&& while (s != null) {&
&&&&&&&&&&&&&&& System.out.println("Read: " + s);&
&&&&&&&&&&&&&&& s = in.readLine();&
&&&&&&&&&&& }&
&&&&&&&&&&&
&&&&&&&&&&& in.close();&
&&&&&&& } catch (IOException e) {
&&&&&&&&&&& e.printStackTrace();&
&&&&&&& }&
import java.io.BufferedR
import java.io.IOE
import java.io.InputStreamR
public class StandardInputOutput {
public static void main(String args[]) {
// 创建缓冲区阅读器从键盘逐行读入数据
InputStreamReader ir = new InputStreamReader(System.in);
BufferedReader in = new BufferedReader(ir);
System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出"
+ "\nWindows系统: ctrl-z 退出");
// 读一行数据，并标准输出至显示器
s = in.readLine();
// readLine()方法运行时若发生I/O错误，将抛出IOException异常
while (s != null) {
System.out.println("Read: " + s);
s = in.readLine();
// 关闭缓冲阅读器
in.close();
} catch (IOException e) { // Catch any IO exceptions.
e.printStackTrace();
& && 在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader；一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了
& &&& Java I/O主要包括如下几个层次，包含三个部分：
1.流式部分――IO的主体部分；
&& 2.非流式部分――主要包含一些辅助流式部分的类，如：File类、RandomAccessFile类和FileDescriptor等类；
& 3.其他类--文件读取部分的与安全相关的类，如：SerializablePermission类，以及与本地操作系统相关的文件系统的类，如：FileSystem类和Win32FileSystem类和WinNTFileSystem类。
& 主要的类如下：
& && 1. File（文件特征与管理）：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。
& && 2. InputStream（二进制格式操作）：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。
& && 3. OutputStream（二进制格式操作）：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。
& && Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。
& && 4. Reader（文件格式操作）：抽象类，基于字符的输入操作。
& && 5. Writer（文件格式操作）：抽象类，基于字符的输出操作。
& && 6. RandomAccessFile（随机文件操作）：它的功能丰富，可以从文件的任意位置进行存取（输入输出）操作。
& && Java中IO流的体系结构如图：
在Java语言的java.io包中，由File类提供了描述文件和目录的操作与管理方法。但File类不是InputStream、OutputStream或Reader、Writer的子类，因为它不负责数据的输入输出，而专门用来管理磁盘文件与目录。
作用：File类主要用于命名文件、查询文件属性和处理文件目录。
public&&& class&& File&& extends Object&&
&&& implements Serializable,Comparable&
extends Object
implements Serializable,Comparable
File类共提供了三个不同的构造函数，以不同的参数形式灵活地接收文件和目录名信息。构造函数： 1）File (String & pathname)&&
&&&& 例:File& f1=new File("FileTest1.txt"); //创建文件对象f1，f1所指的文件是在当前目录下创建的FileTest1.txt 2）File (String& parent& ,& String child)
&&&& 例:File f2=new& File(&D:\\dir1","FileTest2.txt") ;// 注意：D:\\dir1目录事先必须存在，否则异常 3）File (File&&& parent& , String child) &&&& 例:File& f4=new File("\\dir3"); &&&&&&&&& File& f5=new File(f4,"FileTest5.txt");& //在如果 \\dir3目录不存在使用f4.mkdir()先创建
&&&&&&& 一个对应于某磁盘文件或目录的File对象一经创建， 就可以通过调用它的方法来获得文件或目录的属性。&&&
&&&&&& 1）public boolean exists( ) 判断文件或目录是否存在 &&&&&& 2）public boolean isFile( ) 判断是文件还是目录 &&&&&& 3）public boolean isDirectory( ) 判断是文件还是目录 &&&&& 4）public String getName( ) 返回文件名或目录名 & &&&& 5）public String getPath( ) 返回文件或目录的路径。 &&&&&& 6）public long length( ) 获取文件的长度 &&&&&& 7）public String[ ] list ( ) 将目录中所有文件名保存在字符串数组中返回。
&&&&&& File类中还定义了一些对文件或目录进行管理、操作的方法，常用的方法有： &&&&&& 1） public boolean renameTo( File newFile );&&& 重命名文件 &&&&&& 2） public void delete( ); & 删除文件 &&&&&& 3）& public boolean mkdir( ); 创建目录
import java.io.F&
import java.io.IOE&
public class TestFile {&
&&& public static void main(String args[]) throws IOException {&
&&&&&&& File dir = new File("\\root");&
&&&&&&& File f1 = new File(dir, "fileOne.txt");&
&&&&&&& File f2 = new File(dir, "fileTwo.java");&
&&&&&&& if (!dir.exists())&
&&&&&&&&&&& dir.mkdir();&
&&&&&&& if (!f1.exists())&
&&&&&&&&&&& f1.createNewFile();&
&&&&&&& if (!f2.exists())&
&&&&&&&&&&& f2.createNewFile();&
&&&&&&& System.out.println("f1's AbsolutePath=& " + f1.getAbsolutePath());&
&&&&&&& System.out.println("f1 Canread=" + f1.canRead());&
&&&&&&& System.out.println("f1's len= " + f1.length());&
&&&&&&& String[] FL;&
&&&&&&& int count = 0;&
&&&&&&& FL = dir.list();&
&&&&&&& for (int i = 0; i & FL. i++) {&
&&&&&&&&&&& count++;&
&&&&&&&&&&& System.out.println(FL[i] + "is in \\root");&
&&&&&&& }&
&&&&&&& System.out.println("there are" + count + "file in //root");&
import java.io.F
import java.io.IOE
public class TestFile {
public static void main(String args[]) throws IOException {
File dir = new File("\\root");
File f1 = new File(dir, "fileOne.txt");
File f2 = new File(dir, "fileTwo.java");
// 文件对象创建后，指定的文件或目录不一定物理上存在
if (!dir.exists())
dir.mkdir();
if (!f1.exists())
f1.createNewFile();
if (!f2.exists())
f2.createNewFile();
System.out.println("f1's AbsolutePath=
" + f1.getAbsolutePath());
System.out.println("f1 Canread=" + f1.canRead());
System.out.println("f1's len= " + f1.length());
String[] FL;
int count = 0;
FL = dir.list();
for (int i = 0; i & FL. i++) {
System.out.println(FL[i] + "is in \\root");
System.out.println("there are" + count + "file in //root");
说明：File类的方法: (1) exists()测试磁盘中指定的文件或目录是否存在 (2) mkdir()创建文件对象指定的目录（单层目录） (3) createNewFile()创建文件对象指定的文件
(4) list()返回目录中所有文件名字符串
1. io流的四个基本类
& &&& java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类：InputStream、OutputStream及Reader、Writer类，它们分别处理字节流和字符流：
基本数据流的I/O
Inputstream
OutputStream
&&& Java中其他多种多样变化的流均是由它们派生出来的:
&&&&& JDK1.4版本开始引入了新I/O类库，它位于java.nio包中，新I/O类库利用通道和缓冲区等来提高I/O操作的效率。
&&&&& 在java.io包中， java.io.InputStream 表示字节输入流， java.io.OutputStream表示字节输出流，处于java.io包最顶层。这两个类均为抽象类，也就是说它们不能被实例化，必须生成子类之后才能实现一定的功能。
1. io流的具体分类
一、按I/O类型来总体分类：
1. Memory 1）从/向内存数组读写数据: CharArrayReader、 CharArrayWriter、ByteArrayInputStream、ByteArrayOutputStream & &&&&&&&&&&&&&&&& 2）从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream & &
2.Pipe管道& 实现管道的输入和输出（进程间通信）: PipedReader、PipedWriter、PipedInputStream、PipedOutputStream & && 3.File 文件流。对文件进行读、写操作 ：FileReader、FileWriter、FileInputStream、FileOutputStream & && 4. ObjectSerialization 对象输入、输出 ：ObjectInputStream、ObjectOutputStream & & 5.DataConversion数据流 按基本数据类型读、写（处理的数据是Java的基本类型（如布尔型，字节，整数和浮点数））：DataInputStream、DataOutputStream & &
6.Printing 包含方便的打印方法 ：PrintWriter、PrintStream &&& 7.Buffering缓冲
在读入或写出时，对数据进行缓存，以减少I/O的次数：BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream & && 8.Filtering 滤流，在数据进行读或写时进行过滤：FilterReader、FilterWriter、FilterInputStream、FilterOutputStream过 & && 9.Concatenation合并输入 把多个输入流连接成一个输入流 ：SequenceInputStream
&&& 10.Counting计数& 在读入数据时对行记数 ：LineNumberReader、LineNumberInputStream & & 11.Peeking Ahead 通过缓存机制，进行预读 ：PushbackReader、PushbackInputStream &&& 12.Converting between Bytes and Characters 按照一定的编码/解码标准将字节流转换为字符流，或进行反向转换（Stream到Reader,Writer的转换类）：InputStreamReader、OutputStreamWriter
二、按数据来源（去向）分类： 1、File（文件）： FileInputStream,
FileOutputStream, FileReader, FileWriter 2、byte[]：ByteArrayInputStream,
ByteArrayOutputStream 3、Char[]: CharArrayReader,
CharArrayWriter 4、String:
StringBufferInputStream, StringReader, StringWriter 5、网络数据流：InputStream,
OutputStream, Reader, Writer
1. InputStream抽象类
&&& InputStream 为字节输入流，它本身为一个抽象类，必须依靠其子类实现各种功能，此抽象类是表示字节输入流的所有类的超类。 继承自InputStream&
的流都是向程序中输入数据的，且数据单位为字节（8bit）；
InputStream是输入字节数据用的类，所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法： 　　（1）
public abstract int read( )：读取一个byte的数据，返回值是高位补0的int类型值。若返回值=-1说明没有读取到任何字节读取工作结束。　　（2）
public int read(byte b[
])：读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的 　　（3）
public int read(byte b[ ], int off, int
len)：从输入流中最多读取len个字节的数据，存放到偏移量为off的b数组中。 　　（4）
public int available( )：返回输入流中可以读取的字节数。注意：若输入阻塞，当前线程将被挂起，如果InputStream对象调用这个方法的话，它只会返回0，这个方法必须由继承InputStream类的子类对象调用才有用， 　　（5）
public long skip(long n)：忽略输入流中的n个字节，返回值是实际忽略的字节数, 跳过一些字节来读取 　　（6）
public int close( ) ：我们在使用完后，必须对我们打开的流进行关闭.
&&&&&& 主要的子类：
&&&&&& 1）
FileInputStream把一个文件作为InputStream，实现对文件的读取操作&&&& 　　
2） ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用 　　
3） StringBufferInputStream：把一个String对象作为InputStream 　　
4） PipedInputStream：实现了pipe的概念，主要在线程中使用 　　
5） SequenceInputStream：把多个InputStream合并为一个InputStream
2．OutputStream抽象类
　　OutputStream提供了3个write方法来做数据的输出，这个是和InputStream是相对应的。 　　1.
public void write(byte b[ ])：将参数b中的字节写到输出流。 　　2.
public void write(byte b[ ], int off, int len)
：将参数b的从偏移量off开始的len个字节写到输出流。 　　3.
public abstract void write(int b) ：先将int转换为byte类型，把低字节写入到输出流中。 　　4.
public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区。 　　5.
public void close( ) : 关闭输出流并释放与流相关的系统资源。
&&&&&& 主要的子类：
&&& 1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
FileOutputStream：把信息存入文件中
PipedOutputStream：实现了pipe的概念，主要在线程中使用
SequenceOutputStream：把多个OutStream合并为一个OutStream
流结束的判断：方法read()的返回值为-1时；readLine()的返回值为null时。
3. 文件输入流：
FileInputStream类
FileInputStream可以使用read()方法一次读入一个字节，并以int类型返回，或者是使用read()方法时读入至一个byte数组，byte数组的元素有多少个，就读入多少个字节。在将整个文件读取完成或写入完毕的过程中，这么一个byte数组通常被当作缓冲区，因为这么一个byte数组通常扮演承接数据的中间角色。
作用：以文件作为数据输入源的数据流。或者说是打开文件，从文件读数据到内存的类。 使用方法(1)&&&
fin=new File("d:/abc.txt");
& FileInputStream in=new FileInputStream( fin);
使用方法(2) &
FileInputStream& in=new& FileInputStream(&d: /abc.txt&);
程序举例： 将InputFromFile.java的程序的内容显示在显示器上
import java.io.IOE&
import java.io.FileInputS&
public class TestFile {&
&&& public static void main(String args[]) throws IOException {&
&&&&&&& try{&&&&&
&&&&&&&&&&&&&& FileInputStream rf=new&& FileInputStream("InputFromFile.java");&
&&&&&&&&&&&&&& int n=512;&& byte& buffer[]=new& byte[n];&&&&
&&&&&&&&&&&&&& while((rf.read(buffer,0,n)!=-1)&&(n&0)){&
&&&&&&&&&&&&&&&&&& System.out.println(new String(buffer) );&
&&&&&&&&&&&&&&& }&
&&&&&&&&&&&&&&& System.out.println();&
&&&&&&&&&&&&&&& rf.close();&
&&&&&&& } catch(IOException& IOe){&&&&&&&
&&&&&&&&&&&&& System.out.println(IOe.toString());&
&&&&&&& }&
import java.io.IOE
import java.io.FileInputS
public class TestFile {
public static void main(String args[]) throws IOException {
FileInputStream rf=new
FileInputStream("InputFromFile.java");
int n=512;
buffer[]=new
while((rf.read(buffer,0,n)!=-1)&&(n&0)){
System.out.println(new String(buffer) );
System.out.println();
rf.close();
} catch(IOException
System.out.println(IOe.toString());
4.文件输出流:FileOutputStream类
　 作用：用来处理以文件作为数据输出目的数据流；或者说是从内存区读数据入文件
& &&& FileOutputStream类用来处理以文件作为数据输出目的数据流；一个表示文件名的字符串，也可以是File或FileDescriptor对象。 　　创建一个文件流对象有两种方法： 　　方式1： 　　 File
& f=new& File (&d:/myjava/write.txt ");&
&&&&& FileOutputStream& out= new FileOutputStream (f);　　方式2： 　　FileOutputStream
out=new FileOutputStream(&d:/myjava/write.txt "); 　　方式3：构造函数将
FileDescriptor()对象作为其参数。 　　FileDescriptor()
fd=new FileDescriptor(); 　　FileOutputStream
f2=new FileOutputStream(fd); 　　方式4：构造函数将文件名作为其第一参数，将布尔值作为第二参数。 　　FileOutputStream
f=new FileOutputStream("d:/abc.txt",true); 　　注意： （1）文件中写数据时，若文件已经存在，则覆盖存在的文件；（2）的读/写操作结束时，应调用close方法关闭流。
程序举例：使用键盘输入一段文章，将文章保存在文件write.txt中
import java.io.IOE&
import java.io.FileOutputS&
public class TestFile {&
&&& public static void main(String args[]) throws IOException {&
&&&&&&& try {&
&&&&&&&&&&& System.out.println("please Input from&&&&& Keyboard");&
&&&&&&&&&&& int count, n = 512;&
&&&&&&&&&&& byte buffer[] = new byte[n];&
&&&&&&&&&&& count = System.in.read(buffer);&
&&&&&&&&&&& FileOutputStream wf = new FileOutputStream("d:/myjava/write.txt");&
&&&&&&&&&&& wf.write(buffer, 0, count);&
&&&&&&&&&&& wf.close();
&&&&&&&&&&& System.out.println("Save to the write.txt");&
&&&&&&& } catch (IOException IOe) {&
&&&&&&&&&&& System.out.println("File Write Error!");&
&&&&&&& }&
import java.io.IOE
import java.io.FileOutputS
public class TestFile {
public static void main(String args[]) throws IOException {
System.out.println("please Input from
Keyboard");
int count, n = 512;
byte buffer[] = new byte[n];
count = System.in.read(buffer);
FileOutputStream wf = new FileOutputStream("d:/myjava/write.txt");
wf.write(buffer, 0, count);
wf.close(); // 当流写操作结束时，调用close方法关闭流。
System.out.println("Save to the write.txt");
} catch (IOException IOe) {
System.out.println("File Write Error!");
5. FileInputStream流和FileOutputStream的应用
利用程序将文件file1.txt 拷贝到file2.txt中。
import java.io.F&
import java.io.IOE&
import java.io.FileOutputS&
import java.io.FileInputS&
public class TestFile {&
&&& public static void main(String args[]) throws IOException {&
&&&&&&& try {&
&&&&&&&&&&& File inFile = new File("copy.java");&
&&&&&&&&&&& File outFile = new File("copy2.java");&
&&&&&&&&&&& FileInputStream finS = new FileInputStream(inFile);&
&&&&&&&&&&& FileOutputStream foutS = new FileOutputStream(outFile);&
&&&&&&&&&&& &
&&&&&&&&&&& while ((c = finS.read()) != -1) {&
&&&&&&&&&&&&&&& foutS.write(c);&
&&&&&&&&&&& }&
&&&&&&&&&&& finS.close();&
&&&&&&&&&&& foutS.close();&
&&&&&&& } catch (IOException e) {&
&&&&&&&&&&& System.err.println("FileStreamsTest: " + e);&
&&&&&&& }&
import java.io.F
import java.io.IOE
import java.io.FileOutputS
import java.io.FileInputS
public class TestFile {
public static void main(String args[]) throws IOException {
File inFile = new File("copy.java");
File outFile = new File("copy2.java");
FileInputStream finS = new FileInputStream(inFile);
FileOutputStream foutS = new FileOutputStream(outFile);
while ((c = finS.read()) != -1) {
foutS.write(c);
finS.close();
foutS.close();
} catch (IOException e) {
System.err.println("FileStreamsTest: " + e);
6. 缓冲输入输出流 BufferedInputStream/ BufferedOutputStream
&&&&& 计算机访问外部设备非常耗时。访问外存的频率越高，造成CPU闲置的概率就越大。为了减少访问外存的次数，应该在一次对外设的访问中，读写更多的数据。为此，除了程序和流节点间交换数据必需的读写机制外，还应该增加缓冲机制。缓冲流就是每一个数据流分配一个缓冲区，一个缓冲区就是一个临时存储数据的内存。这样可以减少访问硬盘的次数,提高传输效率。
BufferedInputStream:当向缓冲流写入数据时候，数据先写到缓冲区，待缓冲区写满后，系统一次性将数据发送给输出设备。
BufferedOutputStream :当从向缓冲流读取数据时候，系统先从缓冲区读出数据，待缓冲区为空时，系统再从输入设备读取数据到缓冲区。
1）将文件读入内存：
将BufferedInputStream与FileInputStream相接
& FileInputStream in=new& FileInputStream( &file1.txt & );
& BufferedInputStream bin=new& BufferedInputStream( in);
2）将内存写入文件：
将BufferedOutputStream与 FileOutputStream相接
FileOutputStreamout=new FileOutputStream(&file1.txt&);
BufferedOutputStream& bin=new BufferedInputStream(out);
3）键盘输入流读到内存
将BufferedReader与标准的数据流相接
InputStreamReader sin=new InputStreamReader (System.in) ；
BufferedReader bin=new&&&&&&&&&& & BufferedReader(sin);
import java.io.*;&
public class ReadWriteToFile {&
&&& public static void main(String args[]) throws IOException {&
&&&&&&& InputStreamReader sin = new InputStreamReader(System.in);&
&&&&&&& BufferedReader bin = new BufferedReader(sin);&
&&&&&&& FileWriter out = new FileWriter("myfile.txt");&
&&&&&&& BufferedWriter bout = new BufferedWriter(out);&
&&&&&&& S&
&&&&&&& while ((s = bin.readLine()).length() & 0) {&
&&&&&&&&&&& bout.write(s, 0, s.length());&
&&&&&&& }&
import java.io.*;
public class ReadWriteToFile {
public static void main(String args[]) throws IOException {
InputStreamReader sin = new InputStreamReader(System.in);
BufferedReader bin = new BufferedReader(sin);
FileWriter out = new FileWriter("myfile.txt");
BufferedWriter bout = new BufferedWriter(out);
while ((s = bin.readLine()).length() & 0) {
bout.write(s, 0, s.length());
程序说明： 从键盘读入字符，并写入到文件中BufferedReader类的方法：String readLine() 作用：读一行字符串，以回车符为结束。 BufferedWriter类的方法：bout.write(String s,offset,len) 作用：从缓冲区将字符串s从offset开始，len长度的字符串写到某处。
& &&&& Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。
1. Reader抽象类
& & 用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。
&&&&&&& 1) FileReader :与FileInputStream对应& & &&&&&&&& 主要用来读取字符文件，使用缺省的字符编码，有三种构造函数： 　　&&& (1）将文件名作为字符串 ：FileReader f=new FileReader(&c:/temp.txt&); 　　&&& (2）构造函数将File对象作为其参数。 　　&&&&&&&&&&& File f=new file(&c:/temp.txt&); 　　&&&&&&&&&&& FileReader f1=new FileReader(f); 　　&& (3)& 构造函数将FileDescriptor对象作为参数 　　&&&&&&&& FileDescriptor() fd=new FileDescriptor() 　　&&&&&&&&& FileReader f2=new FileReader(fd); &&&&&&&&&&&&&& (1) 用指定字符数组作为参数：CharArrayReader(char[]) & &&&&&&&&&&&& (2) 将字符数组作为输入流:CharArrayReader(char[], int, int) 　&&&&&&&& 读取字符串，构造函数如下： public StringReader(String s); &&&&& & 2) CharArrayReader：与ByteArrayInputStream对应& 　　3) StringReader : 与StringBufferInputStream对应 　　4) InputStreamReader
　　&&&& 从输入流读取字节，在将它们转换成字符:Public inputstreamReader(inputstream is); 　　5) FilterReader: 允许过滤字符流 　　&& && protected filterReader(Reader r); 　　6) BufferReader :接受Reader对象作为参数，并对其添加字符缓冲器，使用readline()方法可以读取一行。 　　&& Public BufferReader(Reader r);
&&&&& 主要方法：
public int read() throws IOE //读取一个字符，返回值为读取的字符
public int read(char cbuf[]) throws IOE /*读取一系列字符到数组cbuf[]中，返回值为实际读取的字符的数量*/
public abstract int read(char cbuf[],int off,int len) throws IOE
　　/*读取len个字符，从数组cbuf[]的下标off处开始存放，返回值为实际读取的字符数量，该方法必须由子类实现*/
2. Writer抽象类
&& 写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和
close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。 其子类如下：
FileWrite: 与FileOutputStream对应
　　将字符类型数据写入文件，使用缺省字符编码和缓冲器大小。
　　Public FileWrite(file
　　2)& chararrayWrite:与ByteArrayOutputStream对应
,将字符缓冲器用作输出。
　　&&& Public CharArrayWrite();
PrintWrite:生成格式化输出
　　&&& public PrintWriter(outputstream
　　4) filterWriter:用于写入过滤字符流
protected FilterWriter(Writer w);
　　5) PipedWriter：与PipedOutputStream对应
&&&&& 6) StringWriter：无与之对应的以字节为导向的stream
&&& 主要方法：
public void write(int c) throws IOException； //将整型值c的低16位写入输出流 　　(2)
public void write(char cbuf[]) throws IOException； //将字符数组cbuf[]写入输出流 　　(3)
public abstract void write(char cbuf[],int off,int len) throws IOException； //将字符数组cbuf[]中的从索引为off的位置处开始的len个字符写入输出流 　　(4)
public void write(String str) throws IOException； //将字符串str中的字符写入输出流 　　(5)
public void write(String str,int off,int len) throws IOException； //将字符串str 中从索引off开始处的len个字符写入输出流 　　(6)
flush( ) //刷空输出流，并输出所有被缓存的字节。 　　(7)close() &
关闭流 public abstract void close() throws IOException
3 .InputStream与Reader差别
OutputStream与Writer差别
InputStream和OutputStream类处理的是字节流，数据流中的最小单位是字节(8个bit) Reader与Writer处理的是字符流，在处理字符流时涉及了字符编码的转换问题
import java.io.*;&
public class EncodeTest {&
&&& private static void readBuff(byte [] buff) throws IOException {&
&&&&&& ByteArrayInputStream in =new ByteArrayInputStream(buff);&
&&&&&&& while((data=in.read())!=-1)&& System.out.print(data+"& ");&
&&&&&&& System.out.println();&&&& in.close();&&&& }&
&& public static void main(String args[]) throws IOException {&
&&&&&& System.out.println("内存中采用unicode字符编码：" );&
&&&&&& char&& c='好';&
&&&&&& int lowBit=c&0xFF;&&&& int highBit=(c&0xFF00)&&8;&
&&&&&& System.out.println(""+lowBit+"&& "+highBit);&
&&&&&& String s="好";&
&&&&&& System.out.println("本地操作系统默认字符编码：");&
&&&&&& readBuff(s.getBytes());&
&&&&&& System.out.println("采用GBK字符编码：");&
&&&&&& readBuff(s.getBytes("GBK"));&
&&&&&& System.out.println("采用UTF-8字符编码：");&&&&&&&
&&&&&& readBuff(s.getBytes("UTF-8"));&&&&& }&
import java.io.*;
public class EncodeTest {
private static void readBuff(byte [] buff) throws IOException {
ByteArrayInputStream in =new ByteArrayInputStream(buff);
while((data=in.read())!=-1)
System.out.print(data+"
System.out.println();
in.close();
public static void main(String args[]) throws IOException {
System.out.println("内存中采用unicode字符编码：" );
int lowBit=c&0xFF;
int highBit=(c&0xFF00)&&8;
System.out.println(""+lowBit+"
"+highBit);
String s="好";
System.out.println("本地操作系统默认字符编码：");
readBuff(s.getBytes());
System.out.println("采用GBK字符编码：");
readBuff(s.getBytes("GBK"));
System.out.println("采用UTF-8字符编码：");
readBuff(s.getBytes("UTF-8"));
Reader类能够将输入流中采用其他编码类型的字符转换为Unicode字符，然后在内存中为其分配内存 Writer类能够将内存中的Unicode字符转换为其他编码类型的字符，再写到输出流中。
1.public class& EOFException ： & 非正常到达文件尾或输入流尾时，抛出这种类型的异常。 2.public class FileNotFoundException： & 当文件找不到时，抛出的异常。 3.public class InterruptedIOException： & 当I/O操作被中断时，抛出这种类型的异常。
相关文章：
阅读(...) 评论()