java中IO流的学习

java IO流涉及到的class 和 interface.

字节流和字符流的区别：

字节流：字节流是一个字节一个字节读取，和一个字节写入，使用于传输任何类型的数据。

字符流：基于字节流，每次需要查询编码表，返回对应的字符，使用于传输字符数据。

一般情况，如果传输的是纯文本数据，建议使用字符流，其他的用字节流。

这些图是我从网上下的，我想对学习java的IO会很有帮助。有什么指点的，还请高手指点。

 

java IO流 class structure picture.

 

InputStream与OutputStream对应图

 

Reader与Writer对应图

 

代码部分：（有点儿多，技术不精，还请高手指点）

package com.wangbiao.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

/**
 * InputStream及其子类的用法。
 * @author wangbiao
 *
 * 2013-4-27上午12:25:56
 */
public class Test_InputStream {

	
	public static void test_read_first(File file) throws Exception{
		InputStream in=new FileInputStream(file);
		byte[] b=new byte[(int) file.length()];
		in.read(b);
		in.close();
		System.out.println(new String(b));
	}
	public static void test_read_second(File file) throws Exception{
		InputStream in=new FileInputStream(file);
		byte[] b=new byte[(int) file.length()];
		int len=in.read(b);
		in.close();
		System.out.println(new String(b,0,len));
	}
	//如果不知道數組的大小，則通過判斷是否讀到文件的末尾。
	public static void test_read_third(File file) throws Exception{
		InputStream in=new FileInputStream(file);
		
		byte[] b=new byte[1024];//file被封装起来，不能调用file.length().
		int temp=0;
		int len=0;
		while((temp=in.read())!=-1){
			b[len]=(byte) temp;
			len++;
		}
		in.close();
		System.out.println(new String(b,0,len));
	}
	
	
	public static void main(String[] args) throws Exception {
		File file=new File("D:"+File.separator+"test.txt");
		//test_read_first(file);
		//test_read_second(file);
		test_read_third(file);
	}
	
}

 

package com.wangbiao.test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;


/**
 * 
 * OutputStream以及其常用子类的用法。
 * @author wangbiao
 * 2013-4-26下午11:58:14
 */
public class Test_OutputStream {


	//将一个字节数组直接写入File里面。
	public static void test_write_first(File file) throws Exception{
		OutputStream out=new FileOutputStream(file,true);//true表示可以追加内容，而不是覆盖原内容。
		String str="test java io";
		byte[] b=str.getBytes();
		out.write(b);
		out.close();
	}
	//将一个字节数组里面的内容一个字节一个字节的写入File里面。
	public static void test_write_second(File file) throws Exception{
		OutputStream out=new FileOutputStream(file,true);//true表示可以追加内容，而不是覆盖原内容。
		//String str="test java io";
		String str="\r\n test java io";//"\r\n"代表换行
		byte[] b=str.getBytes();
		for (int i = 0; i < b.length; i++) {
			out.write(b[i]);
		}
		out.close();
	}
	
	public static void main(String[] args) throws Exception {
		File file=new File("D:"+File.separator+"test.txt");
		//file.delete();
		//test_write_first(file);
		test_write_second(file);
	}
}

 

package com.wangbiao.test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.Reader;



/**
 * Reader及其子类的学习
 * @author wangbiao
 *
 * 2013-4-27上午12:47:46
 */
public class Test_Reader {

	
	public static void test_read_first(File file) throws Exception{
		Reader in=new FileReader(file);
		//注意这里是char[]，而不是byte[]
		char[] c=new char[1024];
		int len=in.read(c);
		in.close();
		System.out.println(new String(c,0,len));
	}
	
	public static void test_read_second(File file) throws Exception{
		Reader in=new FileReader(file);
		//注意这里是char[]，而不是byte[]
		char[] c=new char[(int) file.length()];
		int len=in.read(c);
		in.close();
		System.out.println(new String(c));
	}
	
	public static void test_read_third(File file) throws Exception{
		Reader in=new FileReader(file);
		//注意这里是char[]，而不是byte[]
		char[] c=new char[1024];
		int len=0;
		int temp=0;
		while((temp=in.read())!=-1){
			c[len]=(char) temp;
			len++;
		}
		in.close();
		System.out.println(new String(c,0,len));
	}
	
	public static void main(String[] args) throws Exception{
		File file=new File("D:"+File.separator+"test.txt");
		test_read_first(file);
		test_read_second(file);
		test_read_third(file);
	}
}

 

package com.wangbiao.test;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;


/**
 * Writer及其子类的学习
 * @author wangbiao
 *
 * 2013-4-27上午12:40:55
 */
public class Test_Writer {

	public static void test_write_first(File file) throws Exception{
		Writer out=new FileWriter(file);
		String str="\r\n love java";
		out.write(str);
		out.close();
	
	}
	//append content
	public static void test_write_second(File file) throws Exception{
		Writer out=new FileWriter(file,true);
		String str="\r\n love java";
		out.write(str);
		out.close();
	
	}
	
	public static void main(String[] args) throws Exception {
		File file=new File("D:"+File.separator+"test.txt");
		test_write_first(file);
		test_write_second(file);
	}
	
}

 

package com.wangbiao.test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.OutputStream;
import java.io.Writer;



/**
 * 
 * 比较字节流和字符流的区别
 * @author wangbiao
 *
 * 2013-4-27上午1:01:31
 */
public class Compare_OutputStream_Writer {

	//可以这么理解，字符流的底层是字节流，底层数据的传输都是通过字节流来实现的。字节流可以传输图片，音乐等，而字符流则只能传输与字符有关的内容。
	//字节流不需要缓冲区，是直接操作文件，而字符流则需要缓冲区，
	//例如将内容写入到文件中，字节流是直接写入，字符流，是先把内容写入缓冲区中，然后通过字符流的flush(),和close()方法去触发，将缓冲区的内容传输到文件中。
	
	
	//不需要缓冲区
	public static void test_outputStream(File file) throws Exception{
		OutputStream out=new FileOutputStream(file);
		String str="xxxxxxxxxxxx";
		byte[] b=str.getBytes();
		out.write(b);
		//out.close();不关闭输出流
	}
	//需要缓冲区
	public static void test_writer(File file)throws Exception{
		Writer out=new FileWriter(file,true);
		String str="\r\nxxxxxxxxxx";
		out.write(str);
		//out.flush()和out.close()都可以触发将缓冲区的内容传输到文件中。
		out.flush();
		//out.close();
		
	}
	
	public static void main(String[] args) throws Exception{
		File file=new File("D:"+File.separator+"test.txt");
		test_outputStream(file);
		test_writer(file);
	}
	
}

 

package com.wangbiao.test;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;


/**
 * 
 * 内存操作流ByteArrayInputStream and ByteArrayOutputStream.
 * @author WangBiao
 *2013-4-27上午09:21:30
 */
public class Test_ByteArray {
	
	
	public static void test(File file) throws Exception{
		String str="work hard";
		byte[] b=str.getBytes();
		
		//ByteArrayInputStream(byte[] buf, int offset, int length) 
		//ByteArrayInputStream(byte[] buf) 

		InputStream in=new ByteArrayInputStream(b);
		OutputStream out=new ByteArrayOutputStream();
		int temp=0;
		while ((temp=in.read())!=-1) {
//			System.out.println(temp);//temp是字符的ASCII值
//			out.write(temp);
			char c=(char) temp;
			//转换字符大小写
			out.write(Character.toUpperCase(c));
		}
		
		String string=out.toString();
		out.close();
		in.close();
		System.out.println(string);
	}
	
	
	public static void main(String[] args)throws Exception{
		File file=new File("D:"+File.separator+"test.txt");
		test(file);
	}

}

 

package com.wangbiao.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;


/**
 * 转换流InputStreamReader and OutputStreamWriter,都是将字节流装换成字符流
 * @author WangBiao
 *2013-4-27上午08:49:09
 */
public class Test_InputSteamReader {

	//InputStreamReader
	public static void test_inputStreamReader(File file) throws Exception{
		InputStream in=new FileInputStream(file);
		Reader rd=new InputStreamReader(in);
		char[] c=new char[(int) file.length()];
		rd.read(c);
		rd.close();
		System.out.println(new String(c));
		
	}
	//OutputStreamWriter
	public static void test_outputStreamWriter(File file) throws Exception{
		
		String str="test";
		Writer out=new OutputStreamWriter(new FileOutputStream(file));
		out.write(str);
		out.close();
	}
	
	public static void main(String[] args) throws Exception {
		File file=new File("D:"+File.separator+"test"+File.separator+"test.txt");
		file.setWritable(true);
		test_inputStreamReader(file);
		test_outputStreamWriter(file);
	}
}

 

package com.wangbiao.test;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;


/**
 * 
 * PipedInputStream and PipedOutputStream,用于不同线程之间流的数据传输
 * @author WangBiao
 *2013-4-27上午10:24:51
 */
public class Test_Piped {

	public static void main(String[] args) throws Exception {
		PipedOutputStream_Class send=new PipedOutputStream_Class();
		PipedInputStream_Class receive=new PipedInputStream_Class();
		//连接两个线程管道流。
		send.getOutput().connect(receive.getInput());
		
		new Thread(send).start();
		new Thread(receive).start();
	}
	
	
}
class PipedInputStream_Class implements Runnable{
	private PipedInputStream input=null;
	public PipedInputStream_Class() {
		this.input=new PipedInputStream();
	}
	
	@Override
	public void run() {
		
		byte[] b=new byte[1024];
		int temp=0;
		int len=0;
		try {
			while((temp=input.read())!=-1){
				b[len]=(byte) temp;
				len++;
			}
			input.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println(new String(b,0,len));
	}

	public PipedInputStream getInput() {
		return input;
	}

}

 class PipedOutputStream_Class implements Runnable{
	private PipedOutputStream output=null;
	public PipedOutputStream_Class() {
		this.output=new PipedOutputStream();
	}
	
	@Override
	public void run() {
		String str="test";
		try {
			output.write(str.getBytes());
			output.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}

	public PipedOutputStream getOutput() {
		return output;
	}

}

 

package com.wangbiao.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.PrintStream;

/**
 * 
 * PrintStream
 * 
 * @author WangBiao 2013-4-27上午10:44:34
 */
public class Test_PrintStream {
//	PrintStream(File file) 
//    创建具有指定文件且不带自动行刷新的新打印流。 
//	PrintStream(File file, String csn) 
//    创建具有指定文件名称和字符集且不带自动行刷新的新打印流。 
//	PrintStream(OutputStream out) 
//    创建新的打印流。 
//	PrintStream(OutputStream out, boolean autoFlush) 
//    创建新的打印流。 
//	PrintStream(OutputStream out, boolean autoFlush, String encoding) 
//    创建新的打印流。 
//	PrintStream(String fileName) 
//    创建具有指定文件名称且不带自动行刷新的新打印流。 
//	PrintStream(String fileName, String csn) 
//    创建具有指定文件名称和字符集且不带自动行刷新的新打印流。 

	public static void test_printStream(File file) throws Exception{
		PrintStream ps=new PrintStream(new FileOutputStream(file));
		//虽然没有System.setOut(ps),但还是重定向了，内容输出到了指定的文件
		ps.print("ddddddddd");
		ps.println("ccccccccccc");
		ps.close();
		
	}
	
	//有点儿C语言的意思
	public static void test_format(File file) throws Exception{
		PrintStream ps=new PrintStream(file);
		String name="zhangsan";
		int age=22;
		float score=(float) 97.5;
		char sex='M';
		ps.printf("姓名为：%s;年龄为：%d;分数为：%f;性别为：%c ", name,age,score,sex);
		ps.close();
	}
	

	public static void test_sys_in() throws Exception {
		InputStream in=System.in;
		//若字节数组的大小为奇数，并且数组大小偏小，则输入中文的时候，会出现乱码的情况,原因是一个中文占两个字节，字节数组没有完整的将中文字符装入。
		//byte[] b=new byte[5];
		byte[] b=new byte[1024];
		System.out.print("请输入内容：");
		//in.read(b);
		StringBuffer sb=new StringBuffer();
		int temp=0;
		//中文是乱码，原因是中文占两个字节，不能拆开读取。
		while((temp=in.read())!=-1){
			char c=(char) temp;
			if('\n'==c){
				break;
			}
			sb.append(c);
		}
		System.out.println(sb.toString());
		in.close();
	}

	public static void test_sys_out() {
		//System.out.print()
	}

	public static void test_sys_err() {
		//System.err.print()
	}

	//System.in重定向
	public static void test_sys_in_redirect(File file) throws Exception {
		System.setIn(new FileInputStream(file));
		InputStream input=System.in;
		byte[] b=new byte[1024];
		input.read(b);
		System.out.println(new String(b));
		input.close();
	}
	//System.out重定向
	public static void test_sys_out_redirect(File file) throws Exception {
		PrintStream ps=new PrintStream(file);
		System.setOut(ps);
		System.out.println("love java");
		ps.close();
	}
	
	//System.err重定向
	public static void test_sys_err_redirect(File file) throws Exception {
		PrintStream ps=new PrintStream(file);
		System.setErr(ps);
		System.err.println("love java");
		ps.close();
	}

	public static void main(String[] args) throws Exception {
		File file=new File("D:"+File.separator+"test"+File.separator+"test.txt");
		//test_printStream(file);
		//test_format(file);
		//test_sys_in();
		//test_sys_in_redirect(file);
		test_sys_out_redirect(file);
		test_sys_err_redirect(file);
		
	}
}

 

package com.wangbiao.test;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;


/**
 * DataInputStream and DataOutputStream,就我的理解是，这两个类不同之处是可以读取和写入基本数据类型的数据。
 * 两者搭配起来使用，并且写入和读取的顺序要严格一样
 * @author WangBiao
 *2013-4-27下午03:26:37
 */
public class Test_DataInputStream {

	//DataInputStream(InputStream in) 
	public static void test_DataInputStream(File file) throws Exception{
		InputStream in=new FileInputStream(file);
		DataInputStream input=new DataInputStream(in);
		String name=null;
		float fl=0.0f;
		int classNum=0;
		char[] temp=null;
		char c;
		try {
			while(true){
				temp=new char[200];
				int len=0;
				while((c=input.readChar())!='\t'){
					temp[len]=c;
					len++;
				}
				name=new String(temp,0,len);
				fl=input.readFloat();
				input.readChar();
				classNum=input.readInt();
				input.readChar();
				System.out.printf("姓名为：%s; 分数为: %5.2f; 班级为：%d\n",name,fl,classNum);
			}
		} catch (Exception e) {
		}
		
		input.close();
		
		
		
		
	}
	
	//DataOutputStream(OutputStream out) 
    public static void test_DataOutputStream(File file)throws Exception{
    	OutputStream out=new FileOutputStream(file);
    	DataOutputStream output=new DataOutputStream(out);
    	String[] name=new String[]{"zhangsan","lisi","wangwu"};
    	float[] score={95.5f,86.5f,100f};
    	int[] classNum={1,1,3};
    	for (int i = 0; i < name.length; i++) {
			 output.writeChars(name[i]);
			 output.writeChar('\t');
			 output.writeFloat(score[i]);
			 output.writeChar('\t');
			 output.writeInt(classNum[i]);
			 output.writeChar('\n');
		}
    	output.close();
	}
	public static void main(String[] args) throws Exception{
		File file=new File("D:"+File.separator+"test"+File.separator+"test.txt");	
		test_DataOutputStream(file);
		test_DataInputStream(file);
	}
}

 

package com.wangbiao.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.SequenceInputStream;


/**
 * SequenceInputStream，合并流的主要功能是将两个文件的内容合并成一个文件
 * @author WangBiao
 *2013-4-27下午04:08:37
 */
public class Test_SequenceInputStream {

	public static void test(File file1,File file2,File all) throws Exception{
		if(!all.exists()){
			all.createNewFile();
		}
		InputStream input_first=new FileInputStream(file1);
		InputStream input_second=new FileInputStream(file2);
		InputStream input_all=new FileInputStream(all);
		//SequenceInputStream(InputStream s1, InputStream s2) 
		SequenceInputStream sq=new SequenceInputStream(input_first,input_second);
		byte[] temp= new byte[1024];
		int data=0;
		int len=0;
		while((data=sq.read())!=-1){
			temp[len]=(byte) data;
			len++;
		}
		System.out.println(new String(temp,0,len));
		
	}
	
	public static void main(String[] args)throws Exception{
		File file1=new File("D:"+File.separator+"test"+File.separator+"test.txt");
		File file2=new File("D:"+File.separator+"test"+File.separator+"good.txt");
		File all=new File("D:"+File.separator+"test"+File.separator+"all.txt");
		test(file1,file2,all);
	}
}

 

 

package com.wangbiao.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;



/**
 * ZipOutputStream和ZipInputStream为压缩流,每一个压缩文件都可以称为ZipFile.
 * @author WangBiao
 *2013-4-27下午04:41:01
 */
public class Test_ZipOutputStream {

	//将文件压缩成zip包
	public static void test_zipOutputStream(File file) throws Exception{
		InputStream input=null;
		File zipFile=new File("D:"+File.separator+"test"+File.separator+"test.zip");
		ZipOutputStream zipOut=new ZipOutputStream(new FileOutputStream(zipFile));;
		if(file.isDirectory()){
			File[] files=file.listFiles();
			for (int i = 0; i < files.length; i++) {
				input=new FileInputStream(files[i]);
				zipOut.putNextEntry(new ZipEntry(file.getName()+File.separator+files[i].getName()));
				zipOut.setComment(files[i].getName());
				int temp=0;
				while((temp=input.read())!=-1){
					zipOut.write(temp);
				}
			}
		}else{
		    input=new FileInputStream(file);
			zipOut.putNextEntry(new ZipEntry(file.getName()));
			zipOut.setComment("test zipoutputStream");
			int temp=0;
			while((temp=input.read())!=-1){
				zipOut.write(temp);
			}
		}
		
		input.close();
		zipOut.close();
		
	}
	//getNextEntry();
	//ZipInputStream(InputStream in) 

	public static void test_zipInputStream()throws Exception{
		File file=new File("D:"+File.separator+"test"+File.separator+"test.zip");
		InputStream input=null;
		OutputStream output=null;
		ZipEntry entry=null;
		File outFile=null; 
		ZipFile zipFile=new ZipFile(file);
		ZipInputStream zipInputStream=new ZipInputStream(new FileInputStream(file));
		
		while((entry=zipInputStream.getNextEntry())!=null){
			System.out.println("解压缩"+entry.getName());
			outFile=new File("D:"+File.separator+entry.getName());
			if(!outFile.getParentFile().exists()){
				outFile.getParentFile().mkdir();
			}
			if(!outFile.exists()){
				outFile.createNewFile();
			}
			input=zipFile.getInputStream(entry);
			output=new FileOutputStream(outFile);
			int temp=0;
			while((temp=input.read())!=-1){
				output.write(temp);
			}
		}
		zipInputStream.close();
		input.close();
		output.close();
	}
	
	
	public static void test_zipFile()throws Exception{
		File file=new File("D:"+File.separator+"test"+File.separator+"test.zip");
		ZipFile zipFile=new ZipFile(file);
		System.out.println(zipFile.getName());//D:\test\test.zip
		
	}
	public static void main(String[] args) throws Exception{
//		File file=new File("D:"+File.separator+"test");
//		test_zipOutputStream(file);
//		test_zipFile();
		test_zipInputStream();
	}
	
	
	
}

package com.wangbiao.test;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PushbackInputStream;


/**
 * PushbackInputStream and PushbackReader 为回退流，在数据读取的时候，都是按着顺序读取的，回退流就是讲读取进来的某些数据重新退回到输入流的缓冲区中。
 * @author WangBiao
 *2013-4-27下午06:07:45
 */
public class Test_PushbackInputStream {
	
	
		public static void test() throws IOException{
			InputStream input=new ByteArrayInputStream("www.oschina.net".getBytes());
			PushbackInputStream pushbackInput=new PushbackInputStream(input);
			int temp=0;
			while((temp=pushbackInput.read())!=-1){
				if(temp=='.'){
					pushbackInput.unread(temp);
					temp=pushbackInput.read();//讀出來的依舊是‘.’，因为被退回到缓冲流里面，所有再读的时候，又把它读出来了。
					System.out.print("濾掉"+(char)temp);
				}else{
					System.out.print((char)temp);
				}
			}
			input.close();
			pushbackInput.close();
		}
	
	
      public static void main(String[] args) throws IOException{
    	  test();
}
}