软件开发培训班 >> 编程开发 >> Java


Java I/O系统基础知识

　　本文标签：Java IO

　　编程语言的I/O类库中常常使用流这个抽象的概念，它代表任何有能力产生数据的数据源对象或时有能力接收数据的接收端对象  。“流”概念源于UNIX中的管道（pipe）的概念  。在UNIX中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等，它屏蔽了实际的I/O设备中处理数据的细节  。 一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL  。 流的方向是重要的，根据流的方向，流可以分为两类：输入流和输出流  。其实输入/输出是想对于内存来说的  。 实际上，流的源端和目的端可简单地看成是字节的生产者和消费者，对于输入流，可不必关心它的源端是什么，只要简单地从流中读数据，而对输出流，也可不知道它的目的端，只是简单地往流中写数据  。

　　1: a.流：一组有序的数据序列  。

　　2: b.字节流：数据流中最小的数据单元是字节  。

　　3: c.字符流：数据流中最小的数据单元是字符  。

　　一、java.io包中的类对应两类流

　　一类流直接从指定的位置（如磁盘文件或内存区域）读或写，这类流称为结点流，其他的流则称为过滤流（包装流）
过滤流：一些流可以从文件以及其他地方接收字节，另一些流可以将字节组合成更有用的数据类型  。将一个已经存在的流传递给另一个流的构造方法，将这两种流结合起来，结合后的流被称为过滤流  。过滤器输入流往往是以其它输入流作为它的输入源，经过过滤或处理后再以新的输入流的形式提供给用户，过滤器输出流也类似  。 我们很少用单一的类来创建流对象，而是通过叠合多个对象来提供所期望的功能（即装饰器设计模式）  。

　　java的常用输入、输出流其实都是继承自4个抽象类，分别是

　　◆  基于单字节的InputStream,OutputStream类（面向字节形式的Ｉ/Ｏ）

　　◆ 基于双字节的Unicode代码单元的 Reader， Writer类（面向字符形式的Ｉ/Ｏ）

　　一旦打开输入流后，程序就可从输入流串行地读数据  。从输入流读/写数据的过程一般如下：打开一个流通道-->读取/写信息-->关闭流通道  。

　　在java平台中，有以下两种方式能获得本地平台的字符编码类型：

　　（a）System.getProperty("file.encoding");

　　（b) Charset cs=Charset.defaultCharset();

　　所有的输入流、输出流都可以分为字节（输入、输出）流，字符（输入、输出）流，处理字节的主要是（OutputStream/InputStream） 系列，处理字符的，主要是（Reader/Write）系列  。

　　二、以字节（Byte）为导向的输入流（InputStream系列），这几个类都可以与FileInputStream对象相连以提供有用接口：

　　1) ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用

　　2) StringBufferInputStream(

　　在java1.1中已经弃用了

　　1)把一个String对象作为InputStream，底层实现使用StringBuffer

　　2) FileInputStream：把一个文件作为InputStream，实现对文件的读取操作(文件名、文件、FileDescriptor对象)

　　3) PipedInputStream：实现了pipe的概念，主要在线程中使用（作为多进程中的数据源）

　　4) SequenceInputStream：把多个InputStream合并为一个InputStream

　　以字节（Byte）为导向的输出流（OutputStream系列），可以与ＦilterOutputStream对象相连以提供有用接口：

　　1) ByteArrayOutputStream：在内存中创建缓冲区，把信息存入内存中的一个缓冲区中，缓冲区初始化尺寸（可选）

　　2) FileOutputStream：把信息存入文件中（文件名、文件、FileDescriptor）

　　3) PipedOutputStream：实现了pipe的概念，主要在线程中使用(指定用于多线程的数据的目的地)

　　三、与之对应的（Reader/Writer）系列：

　　1: Reader: 与InputStream相对应，适配器InputStreamReader

　　2: Writer: 与OutputStream相对应，适配器为OutputStreamWriter

　　3: FileReader： 与FileOutputStream相对应

　　4: FileWriter: 与FileOurputStream相对应

　　5: StringReader: 无相对应的类

　　6: StringWriter: 与ByteArrayInputStream相对应

　　7: CharArrayReader: 与ByteArrayOutputStream相对应

　　8: CharArrayWriter: 与ByteArrayOutputStream相对应

　　9: PipedReader: 与PipedInputStream相对应

　　10: PipedWriter: 与PipedOutputStream相对应

　　四、两种不限导向的stream之间的转换(使用适配器类)

　　InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个以字符为导向的stream  。

　　InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符  。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集  。

　　OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节  。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集  。

　　五、通过FilterInputStream从InputStream读取数据：

　　1) DataInputStream：从stream中读取基本类型（int、char，long等）数据  。

　　2) BufferedInputStream：使用缓冲区 ，使用它可以防止每次读取都得进行实际的读操作

　　3) LineNumberInputStream：会记录input stream内的行数，然后可调用getLineNumber()和setLineNumber(int)

　　4) PushbackInputStream：很少用到，一般用于编译器开发

　　通过FilterOutputStream向OutputStream写入：

　　1) DataIOutputStream：可以按照移植方式往stream中输出基本类型（int、char，ｌｏｎｇ等）数据  。

　　2) BufferedOutputStream：使用缓冲区 ，使用它可避免每次发送数据都进行实际的写操作

　　3) PrintStream：产生格式化输出 ，其中DataOutputStream处理数据的存储，PrintStream处理显示

　　六、更改流的行为：

　　尽管BufferedOutputStream是FilterOutputStream的子类，但是BufferedWriter并不是FilterWriter的子类，（FilterWriter是抽象类，没有任何子类）

　　1) 没有与DataInputStream对应的类  。除非在要使用readLine()时改用BufferedReader，否则使用DataInputStream

　　2) BufferedReader：与BufferedInputStream对应

　　3) LineNumberReader：与LineNumberInputStream对应

　　4) PushBackReader：与PushbackInputStream对应

　　5) BufferedWrite：与BufferedOutStream对应

　　6) PrintWrite：与 PrintStream对应

　　七、自我独立的类:RandomAccessFile：

　　这个类适用于有大小已知的记录组成的文件，RandomAccessFile除了实现了DataInput和DataOutput接口（DataInputStream和DataOutputStream也实现了这两个接口）之外，这个类是个完全独立的类，它拥有和别的I/O类型本质不同的行为，可以在一个文件内向前和向后移动，直接从Object派生而来  。

　　1) 可通过RandomAccessFile对象完成对文件的读写操作

　　2) 在产生一个对象时，可指明要打开的文件的性质：r，只读；w，只写；rw可读写

　　3) 可以直接跳到文件中指定的位置

　　RandomAccessFile的大部分功能（不是全部）有nio存储映射文件所取代

　　八、I/O流的典型使用方式：

　　1）缓冲输入文件

  1. import java.io.BufferedReader;  
  2. import java.io.FileReader;  
  3. import java.io.IOException;    
  4. public class BufferedInputFile {  
  5. public static String read(String filename) throws IOException{  
  6. BufferedReader in=new BufferedReader(new FileReader(filename));  
  7. String s;  
  8. StringBuilder sb=new StringBuilder();  
  9. while((s=in.readLine())!=null){  
  10.    sb.append(s+"\n");  
  11. }  
  12. in.close();  
  13. return sb.toString();  
  14. }  
  15. public static void main(String[] args) throws IOException {  
  16. System.out.println(read("C:\\Users\\wubin\\workspace\\Imp\\src\\no9\    
  17. \BufferedInputFile.java"));  
  18. }  
  19. } 

　　2）从内存输入

  1. import java.io.IOException;  
  2. import java.io.StringReader;   
  3. public class MemoryTest {  
  4. public static void main(String[] args) throws IOException {  
  5. StringReader in=new StringReader(BufferedInputFile.read("C:\\Users\\wubin\    
  6. \workspace\\Imp\\src\\no9\\BufferedInputFile.java"));  
  7. int c;  
  8. while((c=in.read())!=-1)  
  9.    System.out.print((char)c);  
  10. }  
  11. } 

　　3）格式化的内存输入

  1. import java.io.ByteArrayInputStream;  
  2. import java.io.DataInputStream;  
  3. import java.io.IOException;  
  4. public class FormattedMemoryInput {  
  5. public static void main(String[] args) throws IOException{  
  6. try{  
  7.    DataInputStream in=new DataInputStream(new ByteArrayInputStream    
  8. (BufferedInputFile.read("C:\\Users\\wubin\\workspace\\Imp\\src\\no9\    
  9. \BufferedInputFile.java").getBytes()));  
  10.    while(true)  
  11.     System.out.print((char)in.readByte());  
  12. }catch(Exception e){     
  13. }  
  14. }  
  15. } 
  1. import java.io.BufferedInputStream;  
  2. import java.io.DataInputStream;  
  3. import java.io.FileInputStream;  
  4. import java.io.FileNotFoundException;  
  5. import java.io.IOException;   
  6. public class TestEOF {  
  7. public static void main(String[] args) throws IOException {  
  8. DataInputStream in=new DataInputStream(new BufferedInputStream(new FileInputStream   
  9. ("C:\\Users\\wubin\\workspace\\Imp\\src\\no9\\BufferedInputFile.java")));  
  10. while(in.available()!=0)  
  11.    System.out.print((char)in.readByte());  
  12. }  
  13. } 

　　4）基本文件输出

  1. import java.io.BufferedReader;  
  2. import java.io.BufferedWriter;  
  3. import java.io.FileWriter;  
  4. import java.io.IOException;  
  5. import java.io.PrintWriter;  
  6. import java.io.StringReader;  
  7. public class BasicFileOutput {  
  8. static String file="E:\\2.txt";  
  9. public static void main(String[] args) throws IOException {  
  10. BufferedReader in=new BufferedReader(new StringReader(BufferedInputFile.read("E:\   
  11. \1.txt")));  
  12. PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter(file)));  
  13. int cout=1;  
  14.     String s;  
  15.     while((s=in.readLine())!=null)  
  16.     out.println(cout++ +" "+s);  
  17.     out.close();  
  18.     System.out.println(BufferedInputFile.read(file));  
  19. }  
  20. } 

　　5）存储和恢复数据

  1. import java.io.BufferedInputStream;  
  2. import java.io.BufferedOutputStream;  
  3. import java.io.DataInputStream;  
  4. import java.io.DataOutputStream;  
  5. import java.io.FileInputStream;  
  6. import java.io.FileOutputStream;  
  7. import java.io.IOException;    
  8. public class StoringAndRecoveringData {  
  9. public static void main(String[] args) throws IOException{  
  10. DataOutputStream out=new DataOutputStream(  
  11.     new BufferedOutputStream(new FileOutputStream("E:\\1.txt")));  
  12.     out.writeUTF("hello");  
  13.     out.writeDouble(1.23);  
  14.     out.writeInt(3);  
  15.     out.close();  
  16.     DataInputStream in=new DataInputStream(  
  17.        new BufferedInputStream(new FileInputStream("E:\\1.txt")));  
  18.     System.out.println(in.readUTF());  
  19.     System.out.println(in.readDouble());  
  20.     System.out.println(in.readInt());  
  21. }  
  22. } 

　　6）读写随机访问文件

  1. import java.io.IOException;  
  2. import java.io.RandomAccessFile;    
  3. public class UsingRandomAccessFile {  
  4. static String file="E:\\1.txt";  
  5. static void display() throws IOException{  
  6. RandomAccessFile rf=new RandomAccessFile(file,"r");  
  7. for(int i=0;i<7;i++)  
  8.    System.out.println("Value "+i+": "+rf.readDouble());  
  9. System.out.println(rf.readUTF());  
  10. rf.close();  
  11. }  
  12. public static void main(String[] args) throws IOException{  
  13. RandomAccessFile rf=new RandomAccessFile(file,"rw");  
  14. for(int i=0;i<7;i++)  
  15.    rf.writeDouble(i*1.414);  
  16. rf.writeUTF("The end of the file");  
  17. rf.close();  
  18. display();  
  19.     rf=new RandomAccessFile(file,"rw");  
  20.     rf.seek(5*8);  
  21.     rf.writeDouble(42.0001);  
  22.     rf.close();  
  23.     display();  
  24. }  
  25. } 

　　PipedInputStream，PipedOutputStream,PipedReader和PipedWriter的价值体现在多线程上（管道流用于任务之间的通信）

　　原文链接：http://www.cnblogs.com/zhxiang/archive/2011/10/14/2212496.html