`
huntfor
  • 浏览: 195215 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

java I-O流（转载）

    博客分类：
  • java
 
阅读更多

原文地址：http://249326109.iteye.com/blog/1321915

Java 的10 流是实现输入/输出的基础，它可以方便地实现数据的输入/输出操作， Java 中把不同的输入/输出源(键盘、文件、网络连接等)抽象表述为"流" (stream) ，通过流的方式允许Java 程序使用相同的方式来访问不同的输入/输出源。stream 是从起源(source) 到接收(sink) 的有序数据。

      流按照相对于内存的方向分为输入流和输出流，也可以按照读写的单位分为字节流和字符流,而且还可以根据流的使用不同分为节点流和封装流（采用了典型的装饰器的设计模式，使得IO流用起来非常灵活）。

 

以下来自core java:

      In the Java API, an object from which we can read a sequence of bytes is called an input stream. An object to which we can write a sequence of bytes is called an output stream. These sources and destinations of byte sequences can be—and often are—files, but they can also be network connections and even blocks of memory. The abstract classes InputStream and OutputStream form the basis for a hierarchy of input/output (I/O) classes.

      Because byte-oriented streams are inconvenient for processing information stored in Unicode (recall that Unicode uses multiple bytes per character), there is a separate hierarchy of classes for processing Unicode characters that inherit from the abstract Reader and Writer classes. These classes have read and write operations that are based on two-byte Unicode code units rather than on single-byte characters.

 

    以下是字节流和字符流的层次图。

 

 

 

 





 
 

 




 


 由上图可看出，java IO 体系中有访问文件，数组，管道和字符串的节点流；以及缓冲流，对象流，推回输入流，特殊流

等高层处理流；还有两个转换流。

 下面程序分别使用了字节和字符读取文件并复制一份，并且与buffered版本进行了对比。

Java代码 复制代码 收藏代码
  1. package stream;   
  2.   
  3. import java.io.BufferedInputStream;   
  4. import java.io.BufferedOutputStream;   
  5. import java.io.BufferedReader;   
  6. import java.io.BufferedWriter;   
  7. import java.io.FileInputStream;   
  8. import java.io.FileOutputStream;   
  9. import java.io.FileReader;   
  10. import java.io.FileWriter;   
  11. import java.io.IOException;   
  12. import java.io.Writer;   
  13.   
  14. public class Streamtest {   
  15.   
  16.     /**  
  17.      * @param args  
  18.      * @throws IOException  
  19.      */  
  20.     public static void main(String[] args) throws IOException {   
  21.         FileInputStream fileInputStream = null;   
  22.         FileOutputStream fileOutputStream = null;   
  23.         FileReader fReader = null;   
  24.         FileWriter fWriter = null;   
  25.         BufferedInputStream bis = null;   
  26.         BufferedOutputStream bos = null;   
  27.         BufferedReader br=null;   
  28.         BufferedWriter bw=null;   
  29.            
  30.         //stream   
  31.         long byteStart =System.currentTimeMillis();   
  32.         try {   
  33.                
  34.             fileInputStream = new FileInputStream("三国演义.txt");   
  35.             fileOutputStream = new FileOutputStream("三国演义副本一.txt");   
  36.             int hasRead = 0;   
  37.             byte[] buf = new byte[10];   
  38.             while ((hasRead = fileInputStream.read(buf)) > 0) {   
  39.                 fileOutputStream.write(buf, 0, hasRead);   
  40.             }   
  41.         } catch (IOException e) {   
  42.             e.printStackTrace();   
  43.         } finally {   
  44.             if (fileInputStream != null)   
  45.                 fileInputStream.close();   
  46.             if (fileOutputStream != null)   
  47.                 fileOutputStream.close();   
  48.             long byteEnd=System.currentTimeMillis();   
  49.             System.out.println("字节复制完毕！花费"+(byteEnd-byteStart)+" ms.");   
  50.         }   
  51.         //buffered stream   
  52.         long bufferedByteStart =System.currentTimeMillis();   
  53.         try {   
  54.                
  55.             fileInputStream = new FileInputStream("三国演义.txt");   
  56.             fileOutputStream = new FileOutputStream("buffered三国演义副本一.txt");   
  57.             bis=new BufferedInputStream(fileInputStream);   
  58.             bos=new BufferedOutputStream(fileOutputStream);   
  59.             int hasRead = 0;   
  60.             byte[] buf = new byte[10];   
  61.             while ((hasRead = bis.read(buf)) > 0) {   
  62.                 bos.write(buf, 0, hasRead);   
  63.             }   
  64.         } catch (IOException e) {   
  65.             e.printStackTrace();   
  66.         } finally {   
  67.             if (bis != null)   
  68.                 bis.close();   
  69.             if (bos != null)   
  70.                 bos.close();   
  71.             long bufferedByteEnd=System.currentTimeMillis();   
  72.             System.out.println("buffered字节复制完毕！花费"+(bufferedByteEnd-bufferedByteStart)+" ms.");   
  73.         }   
  74.            
  75.                
  76.         //reader writer   
  77.         long charStart=System.currentTimeMillis();   
  78.         try {   
  79.             fReader = new FileReader("三国演义.txt");   
  80.             fWriter = new FileWriter("三国演义副本二.txt");   
  81.             char[] cbuf = new char[10];   
  82.             int hasRead = 0;   
  83.             while ((hasRead = fReader.read(cbuf)) > 0) {   
  84.                 fWriter.write(cbuf, 0, hasRead);   
  85.             }   
  86.   
  87.         } catch (IOException e) {   
  88.             // TODO: handle exception   
  89.         } finally {   
  90.             if (fReader != null)   
  91.                 fReader.close();   
  92.             if (fWriter != null)   
  93.                 fWriter.close();   
  94.             long charEnd=System.currentTimeMillis();   
  95.             System.out.println("字符复制完毕！ 花费"+(charEnd-charStart)+" ms.");   
  96.         }   
  97.            
  98.         //buffered reader writer    
  99.         long bufferedCharStart=System.currentTimeMillis();   
  100.         try {   
  101.             fReader = new FileReader("三国演义.txt");   
  102.             fWriter = new FileWriter("buffered三国演义副本二.txt");   
  103.             br=new BufferedReader(fReader);   
  104.             bw=new BufferedWriter(fWriter);   
  105.             char[] cbuf = new char[10];   
  106.             int hasRead = 0;   
  107.             while ((hasRead = br.read(cbuf)) > 0) {   
  108.                 bw.write(cbuf, 0, hasRead);   
  109.             }   
  110.   
  111.         } catch (IOException e) {   
  112.             // TODO: handle exception   
  113.         } finally {   
  114.             if (br != null)   
  115.                 br.close();   
  116.             if (bw != null)   
  117.                 bw.close();   
  118.             long bufferedCharEnd=System.currentTimeMillis();   
  119.             System.out.println("buffered字符复制完毕！花费"+(bufferedCharEnd-bufferedCharStart)+" ms.");   
  120.         }   
  121.   
  122.     }   
  123.   
  124. }  
package stream;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class Streamtest {

	/**
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {
		FileInputStream fileInputStream = null;
		FileOutputStream fileOutputStream = null;
		FileReader fReader = null;
		FileWriter fWriter = null;
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		BufferedReader br=null;
		BufferedWriter bw=null;
		
		//stream
		long byteStart =System.currentTimeMillis();
		try {
			
			fileInputStream = new FileInputStream("三国演义.txt");
			fileOutputStream = new FileOutputStream("三国演义副本一.txt");
			int hasRead = 0;
			byte[] buf = new byte[10];
			while ((hasRead = fileInputStream.read(buf)) > 0) {
				fileOutputStream.write(buf, 0, hasRead);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fileInputStream != null)
				fileInputStream.close();
			if (fileOutputStream != null)
				fileOutputStream.close();
			long byteEnd=System.currentTimeMillis();
			System.out.println("字节复制完毕！花费"+(byteEnd-byteStart)+" ms.");
		}
		//buffered stream
		long bufferedByteStart =System.currentTimeMillis();
		try {
			
			fileInputStream = new FileInputStream("三国演义.txt");
			fileOutputStream = new FileOutputStream("buffered三国演义副本一.txt");
			bis=new BufferedInputStream(fileInputStream);
			bos=new BufferedOutputStream(fileOutputStream);
			int hasRead = 0;
			byte[] buf = new byte[10];
			while ((hasRead = bis.read(buf)) > 0) {
				bos.write(buf, 0, hasRead);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (bis != null)
				bis.close();
			if (bos != null)
				bos.close();
			long bufferedByteEnd=System.currentTimeMillis();
			System.out.println("buffered字节复制完毕！花费"+(bufferedByteEnd-bufferedByteStart)+" ms.");
		}
		
			
		//reader writer
		long charStart=System.currentTimeMillis();
		try {
			fReader = new FileReader("三国演义.txt");
			fWriter = new FileWriter("三国演义副本二.txt");
			char[] cbuf = new char[10];
			int hasRead = 0;
			while ((hasRead = fReader.read(cbuf)) > 0) {
				fWriter.write(cbuf, 0, hasRead);
			}

		} catch (IOException e) {
			// TODO: handle exception
		} finally {
			if (fReader != null)
				fReader.close();
			if (fWriter != null)
				fWriter.close();
			long charEnd=System.currentTimeMillis();
			System.out.println("字符复制完毕！ 花费"+(charEnd-charStart)+" ms.");
		}
		
		//buffered reader writer 
		long bufferedCharStart=System.currentTimeMillis();
		try {
			fReader = new FileReader("三国演义.txt");
			fWriter = new FileWriter("buffered三国演义副本二.txt");
			br=new BufferedReader(fReader);
			bw=new BufferedWriter(fWriter);
			char[] cbuf = new char[10];
			int hasRead = 0;
			while ((hasRead = br.read(cbuf)) > 0) {
				bw.write(cbuf, 0, hasRead);
			}

		} catch (IOException e) {
			// TODO: handle exception
		} finally {
			if (br != null)
				br.close();
			if (bw != null)
				bw.close();
			long bufferedCharEnd=System.currentTimeMillis();
			System.out.println("buffered字符复制完毕！花费"+(bufferedCharEnd-bufferedCharStart)+" ms.");
		}

	}

}

 

结果可以看出，buffered封装后却是提高了效率。

Java代码 复制代码 收藏代码
  1. 字节复制完毕！花费1020 ms.   
  2. buffered字节复制完毕！花费21 ms.   
  3. 字符复制完毕！ 花费90 ms.   
  4. buffered字符复制完毕！花费30 ms.   
字节复制完毕！花费1020 ms.
buffered字节复制完毕！花费21 ms.
字符复制完毕！ 花费90 ms.
buffered字符复制完毕！花费30 ms.

 

关于buffer：首先要知道什么是缓冲，buffering，如CPU和硬盘之间的关系，寄存器或内存就是作为缓冲，如果没有缓冲，当CPU要向硬盘存取数据时，只能直接存取，导致效率低下。
比如总共要读取10个字符，每次用一个，那只能每次从硬盘读一个用一个，如果有缓冲，就能先直接缓冲10个，然后再从缓冲中读一个用一个，出于硬件条件等的天生受限，使用buffering会大大提高效率。

 

PrintStream 和 PrintWriter

 

PrintStream是OutputStream的子类，PrintWriter是Writer的子类，两者处于对等的位置上，所以它们的API是非常相似的。PrintWriter实现了PritnStream的所有print方法。对于PrintStream，所有println方法都在内部调用相应的print方法，比如println(char x)的方法体就是调用print(x);再写入一个平台相关的换行符。PrintStream构建时会在内部new一个BufferedWriter，所有print方法都在内部调用这个Writer的write方法（write(String)或write(char[])）——对于print(char[])，直接调用write(char[])；对于其他的print方法，先用String.valueOf获得参数的字符串表示，然后调用write(String)。
         对于PrintWriter，所有println方法也都在内部调用print方法，print方法调用write方法。传入OutputStream时，PrintWriter会在内部构造一个BufferedWriter；而传入Writer时，PrintStream内部直接使用该Writer，此时PrintWriter是否进行了缓冲全看该Writer。
所以，对于使用print系列方法的场合，二者没什么区别。

         但是，PrintStream是字节流，它有处理raw byte的方法，write(int)和write(byte[],int,int)；PrintWriter是字符流，它没有处理raw byte的方法。PrintStream和PrintWriter的auto flushing机制有点不同，前者在输出byte数组、调用println方法、输出换行符或者byte值10（即\n）时自动调用flush方法，后者仅在调用println方法时发生auto flushing。

分享到：
| java泛型（原创+转载整理）
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics