Java复习7.输入输出流 20131005
前言：
Java中涉及数据的读写，都是基于流的，这一块的知识相当重要，而且在Java中的数据，char字符是16bit的，所以存在字节流和字符流的区别。如果是字符文件的输入输出，使用字符流（以Reader/Writer为抽象基类），而其他的数据是二进制的，需要使用字节流（以InputStream和OutputStream为抽象基类）。
其实不止文件，网络数据传输也是输入输出流。
目录
1.字节流和字符流... 2
1.1字节输入流：... 2
1.2字节输出流：... 5
2.字符流... 6
2.1字符数据流输入：... 6
2.2字符数据流输出：... 7
3.使用缓冲数据流，提高IO的效率，减少IO的次数... 7
3.1缓冲字节流: 8
3.2缓冲字符流：... 9
为了便于理解，附图一张：
1.字节流和字符流
字节流就是数据的基本单位是byte，字符流使用字符组成的，基本单位是char，在Java中char是由两个字节保存的。所有的InputStream/OutputStream的子类都可以用于处理二进制数据，他是按照字节存储的，但是对于字符的文本文件，使用字符流比较好。
首先是字节流，基类是InputStream/OutputStream
1.1字节输入流：
InputStream in = null;
try {
String filePath = ClassLoader.getSystemResource("a.txt").getPath();
System.out.println("FilePath:"+filePath);
/*
* 以字节流的方式打开文件，读取的是一个二进制流 byte[] ,如果不存在该文件，则会抛出异常，FileNotFoundException *
*/
in = new FileInputStream(filePath);
byte[] buf = new byte[100];
// read file from inputstream
/*
* public int read(); read next byte data, if to the file end return -1;
* public int read(byte[] buf);
* Reads up to b.length bytes of data from this input stream into an array of bytes.
* return the total number of bytes read into the buffer, or -1 if there is no more data
* because the end of the file has been reached.
* we should clear the buf or record the read byte number.
*
*/
if(in != null){
/*
* 比较正规的读取方式，这样每一次获取的是一定字节数的byte，保存在响应的字节中，然后
* 将字节数组转换成String输出结果
*/
/*int read_byte_number = -1;
int count = 0;
while( (read_byte_number = in.read(buf, 0, 100)) != -1){
System.out.print(new String(buf,0,read_byte_number));
count++;
}
System.out.println("count:" + count);
*/
/*
* 在文件中的数据，一个ASCII对应的是一个字节，但是一个汉字或者其他的字符，保存在文件中是两个字节
* 我们读取的时候使用read只是读取的一个字节，所以对于ASCII的字符是可以读取出来的，返回值对应的ASCII的int
* 可以将它转换成相应的char；但是对于汉字是不可以的，每次只是读取的一个字符。
*/
int i = in.read();
System.out.println(i+":" + (char)i);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(in != null){
try {
in.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
1.2字节输出流：
OutputStream out = null;
try {
/*
* if the file does not exist, it will create the file
* if the file exists, but append default is false, it will clear the file write new content
* we can use the parameter append = true to append context to the end
*/
out = new FileOutputStream("b.txt",true);
out.write('腾');
/*
* public void write(int b); 可以是一个char但是，如果在ASCII之外的字符，就只能写一byte结构很坑，不可预期
* public void write(byte[] buf);
* public void write(byte[] buf, int start, int length);
*/
} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(out != null){
try {
out.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2.字符流
使用字节流是不可以处理中文的，这样我们就必须使用字符流。字符流的基类是Reader/Writer
Reader BufferedReader
InputStreamReader FileReader
Writer BufferedWriter
OutputStreamWriter FileWriter
PrintWriter
这几个是常见的使用的。
2.1字符数据流输入：
Reader reader= null;
try {
reader = new FileReader(ClassLoader.getSystemResource("a.txt").getPath());
char[] buf = new char[10];
int count = 0;
while((count = reader.read(buf,0,10)) != -1){
System.out.print(new String(buf,0,count));
}
/*
* use public int read() function return 0x0000~0xffff int value
*/
/*int a;
while((a=reader.read()) != -1){
System.out.println((char)a);
}
*/
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(reader != null){
try {
reader.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2.2字符数据流输出：
Writer out = null;
try {
// FileWriter(String filename, boolean append = false);
//FileWriter(File file, boolean append = false);
out = new FileWriter("a.txt",true);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
char buf[] = {'杨','腾','飞','a','b','c'};
if(out != null){
try {
System.out.println(new String(buf,0,buf.length));
out.write(buf, 0, buf.length);
out.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(out != null){
try {
out.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
3.使用缓冲数据流，提高IO的效率，减少IO的次数
2中的操作数据流的方法特别低效，不适合远程操作或者是大型项目，我们使用缓冲数据流提高IO的性能。
3.1缓冲字节流:
InputStream FileInputStream
FilterInputStream BufferedInputStream
OutputStream FileOutputStream
FilterOutputStream BufferedOutputStream
将FileInputStream/FileOutputStream转换成
BufferedInputStream/BufferedOutputStream
BufferedInputStream bis = null;
try {
bis = new BufferedInputStream(new FileInputStream("a.txt"));
byte [] buf = new byte[10];
int count = -1;
while( (count = bis.read(buf, 0, 10)) != -1){
System.out.print(new String(buf,0,count));
}
} 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();
}
}
}
BufferedOutputStream bos = null;
try {
bos = new BufferedOutputStream(new FileOutputStream("b.txt",true));
byte[] buf = null;
String a = "杨腾飞a";
buf = a.getBytes();
bos.write(buf,0,buf.length);
bos.flush();
} 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.flush();
bos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
3.2缓冲字符流：
BufferedReader/BufferedWriter
BufferedReader breader = new BufferedReader(new FileReader(“filename”))
Example:
BufferedReader breader = null;
try {
breader = new BufferedReader(new FileReader("a.txt"));
char[] buf = new char[10];
int count = -1;
while( (count = breader.read(buf, 0, 10)) != -1){
System.out.print(new String(buf,0,count));
}
//每一次获取一行数据，当遇到行结束的时候，终止，返回的是一个字符串，但是不包含换行符。
/*
String a ;
while((a=breader.readLine()) != null){
System.out.println(a);
}
*/
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
缓冲输出流的话，详细你也会了吧，就这样了
在Java 中的输入输出流是十分重要的一个知识点，后面的网络编程也是需要用到这些输入输出流。
追梦的飞飞
于广州中山大学 20131005
HomePage: http://yangtengfei.duapp.com