java io流

package website;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;

/*
 * 抽象基类			节点流（文件流）                                缓冲流（处理流的一种,可以提升文件操作的效率）
 * InputStream		FileInputStream			BufferedInputStream
 * OutputStream		FileOutputStream		BufferedOutputStream  (flush())
 * Reader			FileReader				BufferedReader  (readLine())
 * Writer			FileWriter				BufferedWriter  (flush())
 */
public class MyIO {
	
	//读写字节文件，如图片
	public void readWriteForByteFile() throws Exception {
		File file1 = new File("1.jpg");  //读取的文件
		File file2 = new File("2.jpg");  //写入的文件
		
		InputStream is = new FileInputStream(file1); //字节输入流
		BufferedInputStream bis = new BufferedInputStream(is); //缓冲字节输入流
		
		OutputStream os = new FileOutputStream(file2); //字节输出流
		BufferedOutputStream bos = new BufferedOutputStream(os); //缓冲字节输出流
		
		//使用缓冲字节流可以提升性能
		
		byte[] b = new byte[1024]; // 定义一个字节空数组，用来存储每次读或写的数据，数组长度为1024个字节，即1k
		int len; //每次循环读取到的字节数，若为-1表示已经读完
		while((len = bis.read(b)) != -1){  //循环读取的数据，直到返回-1
			bos.write(b, 0, len);  //写入len长度的字节数据到2.jpg
		}
		
		//冲洗内存中的数据，如果最后一次循环 ，b数组没有被填满，则需要手动调用flush强制把数据写出去，在bos.close时其实也会调用该方法，为了保险这里我们手动调用一次
		bos.flush(); 
		
		//关闭输出流
		bos.close(); 
		os.close();
		
		//从后到前进行关闭，先关输出流，再关输入流，这里是要判断是否为null时，才关闭，或者使用java7的新特性try-with-resources来关闭流
		//其实关闭处理流的bos.close方法时，它默认也会调用节点流os.close()
		
		//关闭输入流
		bis.close();
		is.close();
		
	}
	
	//读写字符文件，如txt
	public void readWriteForStringFile() throws Exception {
		File file1 = new File("1.txt");  //读取的文件
		File file2 = new File("2.txt");  //写入的文件
		
		Reader reader = new FileReader(file1);  //字符输入流
		BufferedReader br = new BufferedReader(reader); //缓冲字符输入流
		
		Writer writer = new FileWriter(file2); //字符输出流
		BufferedWriter bw = new BufferedWriter(writer); //缓冲字符输出流
		
		//使用缓冲字符流可以提升性能
		
		String str; //每次循环读取到一行的字符，若为null表示已经读完
		while ((str = br.readLine()) != null) { //循环读取一行数据，直到返回null
			bw.write(str + "\n");
		}
		
		bw.flush();
		
		bw.close();
		br.close();
	}
	
	//字节流转换为字符流
	public void byteConvertString() throws Exception{
		File file1 = new File("1.txt");  //读取的文件
		File file2 = new File("2.txt");  //写入的文件
		
		InputStream is = new FileInputStream(file1);  //字节输入流
		InputStreamReader isr = new InputStreamReader(is, "utf-8"); //转换为字符输入流
		BufferedReader br = new BufferedReader(isr); //缓冲字符输入流
		
		OutputStream os = new FileOutputStream(file2); //字节输出流
		OutputStreamWriter osw = new OutputStreamWriter(os, "utf-8"); //转换为字符输出流
		BufferedWriter bw = new BufferedWriter(osw); //缓冲字符输出流
		
		//此处省略读写操作
		
		bw.close();
		br.close();
		
		
	}
	
	//随机访问文件，程序可以跳到文件的任意位置进行读写
	public void RandomAccessFile(){
		//RandomAccessFile raf = new RandomAccessFile(file, mode)
		//待补充
	}
}

CharArrayWriter的使用示例

InputStream is = request.getInputStream()  //这里模拟从http请求中拿到的输入流
InputStreamReader isr = new InputStreamReader(is, "utf-8");  //将输入流转化为字符流
char[] cbuf = new char[1024];       //定义每次从字符流中读取多少个字符
int len;                            //每次循环读取到的字符数
CharArrayWriter caw = new CharArrayWriter(1024);  //定义一个CharArrayWriter用来写入字符，构造参数为字符的初始大小
//循环从字符流中读取字符到cbuf，并返回读取到多少个字符len，当len=-1时说明没有字符流中没有字符了
while ((len = isr.read(cbuf)) != -1) {            
	//将读取到的字符写入CharArrayWriter
	//第一个参数为拟写入的数据，第二个参数为从数据源的什么位置开始写入，第三个参数写入多少个字符
	//这里所说的写数据是指从一个数据源中（这里就是cbuf）读取它的数据到CharArrayWriter中，在用CharArrayWriter输出数据
	caw.write(cbuf, 0, len);      
}
System.out.println(caw.toString()); //输出字符串
caw.close();
isr.close();
is.close();

ByteArrayOutputStream的使用演示

InputStream is = request.getInputStream()  //这里模拟从http请求中拿到的输入流
byte[] b = new byte[4096];          //定义每次从输入流中读取多少个字节，这里是4k
int len;                            //每次循环读取到的字节数
ByteArrayOutputStream baos = new ByteArrayOutputStream(4096); //定义一个ByteArrayOutputStream用来写入字节，构造参数为字节的初始大小
//循环从字符流中读取字符到b，并返回读取到多少个字节len，当len=-1时说明没有输入流中没有字节了
while ((len = is.read(b)) != -1) {            
	//将读取到的字节写入ByteArrayOutputStream
	//第一个参数为拟写入的数据，第二个参数为从数据源的什么位置开始写入，第三个参数写入多少个字节
	//这里所说的写数据是指从一个数据源中（这里就是b）读取它的数据到ByteArrayOutputStream中，在用ByteArrayOutputStream输出数据
	baos.write(b, 0, len);     
}
System.out.println(baos.toByteArray());          //输出byte[]
System.out.println(baos.toString("utf-8"));      //如果数据是字符串可以调用toString()
baos.close();
is.close();