IO流学习总结(三)

1.BufferedInputStream(缓冲输入流)

BufferedInputStream：就是带缓冲区的输入流，它提高了文件的读取性能。

它的构造方法是：
BufferInputStream(InputStream in)；
创建一个新的缓冲输入流，以将数据读入输入流。

例子：

BufferedInputStream bis = null;
	try {
		
		bis = new BufferedInputStream(new FileInputStream("a.txt"));
		
		byte[] bs = new byte[1024];
		int len = 0;
		
		while((len = bis.read(bs))!=-1) {
			System.out.println(new String(bs, 0, len));
		}
		
	} catch (FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}finally {
		if(bis!=null) {
			try {
				bis.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

2.BufferedOutputStream(缓冲输出流)

BufferedOutputStream: 就是带缓冲区的输出流，能够提高文件的写入效率。
它的构造方法:
BufferedOutputStream(OutputStream out)；
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。

例子：

BufferedOutputStream bos = null;
try {
	bos = new BufferedOutputStream(new FileOutputStream("a.txt"));
	bos.write("Hello World!".getBytes());//默认是覆盖
} catch (FileNotFoundException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}finally {
	if(bos!=null) {
		try {
			bos.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

Test：使用 BufferedInputStream 和 BufferedOutputStream 实现文件的复制。使用高效字节流来进行的文件复制会比基本字节流更快，效率更高。

代码如下：

package com.cn.copyTest;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test {

public static void main(String[] args)  {
	// TODO Auto-generated method stub
	String src = "E:\\Demo\\a.txt";
	String des = "F:\\Test\\a.txt";
	method2(src,des);
}
public static void method2(String src,String des) {
	BufferedInputStream bis = null;
	BufferedOutputStream bos = null;
	try {
		bis = new BufferedInputStream(new FileInputStream(src));
		bos = new BufferedOutputStream(new FileOutputStream(des));
		byte[] bs = new byte[1024];
		int len = 0;
		while((len = bis.read(bs))!=-1) {
			bos.write(bs,0,len);
		}
	} catch (FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}finally {
		//关闭流，释放资源
		if(bis!=null) {  //防止出现空指针异常
			try {
				bis.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}if(bos!=null) {
			try {
				bos.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}	
	}	
}

字符流

字符流就是把字节流转成字符流，即使字符流=字节流+编码表。

OutputStreamWriter

OutputStreamWriter(OutputStream out):根据默认编码字节把流数据转换为字符流。
OutputStreamWriter(OutputStream out, String charsetName):根据指定编码把字节流数据转换为字符流。

例子如下：

  OutputStreamWriter osw = new OutputStreamWriter(
  new FileOutputStream("osw.txt"),"UTF-8");//默认是GBK
  osw.write("中国啦啦啦啦");
  osw.close();

OutputStreamWriter的方法：
void writer(int c):写一个字符。
void writer(char[] cbuf):写一个字符数据。
void writer(String str)：写一个字符串。
void writer(String str,int off,int len);写一个部分字符串，len是字节的长度 off字节数组的起始下标。
void writer(char[] chs,int off,int len);与上面意思一样，写的是一个字符数组。

例子：

public static void main(String[] args) {
	OutputStreamWriter osw = null;
	
	try {
		osw  = new OutputStreamWriter(new FileOutputStream("F:/Test/osw2.txt"), "UTF-8");
		osw.write("你");
		osw.write("好");
		osw.flush();//刷新缓冲区
	} catch (UnsupportedEncodingException | FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}finally {
		if(osw!=null){
			try {
				osw.close();//先刷新,再关闭流。 
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}		
}

InputStreamReader

InputStreamReader(InputStream in)
创建一个使用默认字符集的InputStreamReader。
InputStreamReader(InputStream in, String charsetName):用指定的编码读取数据。

InputStreamReader的方法：
int read()
读一个字符
int read(char[] cbufn)
将字符读入数组
例子:

public static void main(String[] args)  {
	InputStreamReader isr = null;
	try {
		isr = new InputStreamReader(new FileInputStream("a.txt"),"utf-8");
		char[] c = new char[1024];
		int len = 0;
		while((len=isr.read(c))!=-1) {
			System.out.print(new String(c,0,len));
		}
	} catch (UnsupportedEncodingException | FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}finally {
		if(isr!=null) {
			try {
				isr.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}	
}

因为转换流(InputStreamReader/OutputStreamWriter)的名称有点长，所以，Java就提供了子类供我们使用
OutputStreamWriter = FileOutputStream + 编码(GBK);
FileWriter = FileOutputStream + 编码(GBK);
InputStreamReadr = FileInputStream + 编码(GBK);
FileReader = FileInputStream + 编码(GBK);

案例：用FileWriter和FileReader来进行文件复制的操作。

public static void main(String[] args) {
	FileReader fr = null;
	FileWriter fw = null;
	try {
		 fr = new FileReader("F:\\File练习题\\a\\a.txt");
		 fw = new FileWriter("F:\\File练习题\\b\\b.txt");
		 char[] ch = new char[1024];
		 int len = 0;
		 while((len = fr.read(ch))!=-1) {
			 fw.write(ch, 0, len);
			 fw.flush();
		 } 
	} catch (FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}finally {
		if(fr!=null) {
			try {
				fr.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		if(fw!=null) {
			try {
				fw.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}	
}

BufferedReader（缓冲流）

就是字节输入缓冲流，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

例子：

	public static void main(String[] args) throws IOException {
	// TODO Auto-generated method stub
	BufferedReader br = new BufferedReader(new FileReader("E:/Demo/bw.txt"));	
	char[] chs = new char[1024];
	int len =0;
	while((len = br.read(chs))!=-1){
		System.out.println(new String(chs,0,len));
	}
	br.close();
}

BufferedWriter （缓冲流）

BufferedWriter：字符缓冲输出流
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入
可以指定缓冲区的大小，或者接受默认的大小，在大多数情况下，默认值就够了。

例子：

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
	BufferedWriter bw = new BufferedWriter(new FileWriter("E:/Demo/bw.txt"));
	bw.write("Hello World");
	bw.write("JavaScrpt");
	bw.write("好好学习天天向上");
	bw.flush();
	bw.close();
}

字符缓冲流的特殊方法：
BufferedWriter:
newLine():换行
BufferedReader:
readLine()：一次性读一行数据
包含该行内容的字符串，不包含任何终止符，如果已达到流末尾，则返回null

Test:用BufferedWriter和BufferedReader 对文本文件进行复制 (用换行和读行的操作)。

public static void main(String[] args) throws IOException {
	// TODO Auto-generated method stub

	BufferedReader br = new BufferedReader(new FileReader("F:\\File练习题\\a\\\\a.txt"));
	BufferedWriter bw = new BufferedWriter(new FileWriter("F:\\File练习题\\b\\b.txt"));
	String str = null;
	while((str = br.readLine())!=null) {  //一次读一行，直到末尾
		bw.write(str);
		bw.newLine();  // 一次写一行然后换行
		bw.flush();		//每次写完进行刷新
	}
	br.close();
	bw.close();	
}

补充：
close()和flush()的区别？

close():关闭流对象，但是先刷新一次缓冲区。关闭之后，流对象就不能继续再使用了。
flush():仅仅是刷新缓冲区而已，流对象还是可以继续使用的。