Java的IO流分为底层节点流和上层处理流,其中节点流用于和底层的物理节存储点直接关联——不同的物理节点获取节点流的方式可能存在差异,但程序可以把不同的物理节点包装成统一的处理流,从而允许程序使用统一的输入,输出代码来读取不同的物理存储节点的资源。
2.字节流
2.1InputStream抽象类
InputStream是所有字节流中输入流的抽象基类。
2.1.1FileInputStream类
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStreamTest {
	public static void main(String[] args) {
		try {
			//创建一个字节输入流
			FileInputStream fis=new FileInputStream("src/com/t/lavor_zl.txt");
			byte[] buf=new byte[1024];//创建长度为1024的字节数组
			int hasRead=0;//用来保存实际读取的字节数
			/*read()方法还有两种重载:read()读取一个字节,返回读取的字节;
                        *read(char[] buf,int off,int len)从off位置开始读取len个字节
                        *并将它存储在buf中,返回实际读取字节的个数
                        */
			while((hasRead=fis.read(buf))>0){
				System.out.println(new String(buf,0,hasRead));
			}
			fis.close();//关闭输入流
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
	}
}import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamTest {
	public static void main(String[] args) {
		try {
			FileOutputStream fos=new FileOutputStream("src/com/t/lavor.txt");
			byte[] buf=new byte[1024];
			String str="lavor_zl";
			buf=str.getBytes();//将字符串转换成字符数组
                        /*
                                          *write()方法还有两种重载:writer(int b)将指定的字节输出到输入流;
                        * writer(byte[] buf)将字符数组输出到输出流
                        */
			fos.write(buf, 0, str.length());
			fos.close();//关闭输出流
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderTest {
	public static void main(String[] args) {
		try {
			//创建一个输入流
			FileReader fr=new FileReader("src/com/t/lavor_zl.txt");
			char[] buf=new char[1024];
			int hasRead=0;
			
			/*read()方法还有两种重载:read()读取一个字符,返回读取的字符;
			*read(char[] buf,int off,int len)从off位置开始读取len个字符
			*并将它存储在buf中,返回实际读取字符的个数
			*/
			while((hasRead=fr.read(buf))>0){
				System.out.println(new String(buf,0,hasRead));
			}
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}import java.io.FileWriter;
import java.io.IOException;
public class FileWriterTest {
	public static void main(String[] args) {
		try {
			FileWriter fw=new FileWriter("src/com/t/lavot.txt");
			char[] buf=new char[]{'l','a','v','o','r'};
			fw.write(127);//输入指定字符到输出流,参数是int型
			fw.write(buf);//输入指定字符数组到输出流
			fw.write(buf, 0, 3);//从指定字符数组中输出从0位置开始的3个字符到输出流
			fw.write("lavor_zl");//输入指定字符串到输出流
			fw.write("lavor_zl", 0, 3);//从指定字符串中输出从0位置开始的3个字符到输出流
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}
| 分类 | 字节输入流 | 字节输出流 | 字符输入流 | 字符输出流 | 
|---|---|---|---|---|
| 抽象基类 | InputStream | OutputStream | Reader | Writer | 
| 访问文件 | FileInputStream | FileOutputStream | FileReader | FileWriter | 
| 访问数组 | ByteArrayInputStream | ByteArrayOutputStream | CharArrayReader | CharArrayWriter | 
| 访问管道 | PipedInputStream | PipedOutputStream | PipedReader | PipedWriter | 
| 访问字符串 | StringReader | StringWriter | ||
| 缓冲流 | BufferedInputStream | BufferedOutputStream | BufferedReader | BufferedWriter | 
| 转换流 | InputStreamReader | OutputStreamWriter | ||
| 对象流 | ObjectInputStream | ObjectOutputStream | ||
| 抽象基类 | FilterInputStream | FilterOutputStream | FilterReader | FilterWriter | 
| 打印流 | PrintStream | PrintWriter | ||
| 推回输入流 | PushbackInputStream | PushbackReader | ||
| 特殊流 | DataInputStream | DataOutputStream | 
原文地址:http://blog.csdn.net/lavor_zl/article/details/41788499