字节流 Stream
字符流 Reader/Writer
他们都是抽象类，所以不能直接new。
Stream主要操作byte流，而Reader/Writer用来操作字符流。读取文本文件时一般用后者。
java的一个字符（char）是16bit的，一个BYTE是8bit的
Stream是写入一串8bit的数据的。
Reader/Writer是写入一串16bit的数据的。
String缺省是用UNICODE编码，是16bit的。因此用Reader/Writer写入的字符串，跨平台性好一些吧。
Stream的可能会出现字符集乱码吧。
Stream是用来操作byte,
Reader/Writer是用来操作Unicode,
一般需要处理中文时用Reader/Writer好了
Stream用于二进制文件（非文本）
Reader/Writer用于文本文件（虽然也是二进制，不过是按照一定的字符编码规则，不像前者）
当然Stream也可用于文本，只不过比Reader/Writer来的麻烦 。
实际上字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件，如图所示。
下面以两个写文件的操作为主进行比较，但是在操作时字节流和字符流的操作完成之后都不关闭输出流。
范例：使用字节流不关闭执行
package org.lxh.demo12.byteiodemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class OutputStreamDemo05 {
public static void main(String[] args) throws Exception { // 异常抛出， 不处理
// 第1步：使用File类找到一个文件
File f = new File("d:" + File.separator + "test.txt"); // 声明File 对象
// 第2步：通过子类实例化父类对象
OutputStream out = null;
// 准备好一个输出的对象
out = new FileOutputStream(f);
// 通过对象多态性进行实例化
// 第3步：进行写操作
String str = "Hello World!!!";
// 准备一个字符串
byte b[] = str.getBytes();
// 字符串转byte数组
out.write(b);
// 将内容输出
// 第4步：关闭输出流
// out.close();
// 此时没有关闭
}
} 程序运行结果：
此时没有关闭字节流操作，但是文件中也依然存在了输出的内容，证明字节流是直接操作文件本身的。而下面继续使用字符流完成，再观察效果。
范例：使用字符流不关闭执行
package org.lxh.demo12.chariodemo;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class WriterDemo03 {
public static void main(String[] args) throws Exception { // 异常抛出， 不处理
// 第1步：使用File类找到一个文件
File f = new File("d:" + File.separator + "test.txt");// 声明File 对象
// 第2步：通过子类实例化父类对象
Writer out = null;
// 准备好一个输出的对象
out = new FileWriter(f);
// 通过对象多态性进行实例化
// 第3步：进行写操作
String str = "Hello World!!!";
// 准备一个字符串
out.write(str);
// 将内容输出
// 第4步：关闭输出流
// out.close();
// 此时没有关闭
}
} 程序运行结果：
程序运行后会发现文件中没有任何内容，这是因为字符流操作时使用了缓冲区，而 在关闭字符流时会强制性地将缓冲区中的内容进行输出，但是如果程序没有关闭，则缓冲区中的内容是无法输出的，所以得出结论：字符流使用了缓冲区，而字节流没有使用缓冲区。
提问：什么叫缓冲区？
在很多地方都碰到缓冲区这个名词，那么到底什么是缓冲区？又有什么作用呢？
回答：缓冲区可以简单地理解为一段内存区域。
可以简单地把缓冲区理解为一段特殊的内存。
某些情况下，如果一个程序频繁地操作一个资源（如文件或数据库），则性能会很低，此时为了提升性能，就可以将一部分数据暂时读入到内存的一块区域之中，以后直接从此区域中读取数据即可，因为读取内存速度会比较快，这样可以提升程序的性能。
在字符流的操作中，所有的字符都是在内存中形成的，在输出前会将所有的内容暂时保存在内存之中，所以使用了缓冲区暂存数据。
如果想在不关闭时也可以将字符流的内容全部输出，则可以使用Writer类中的flush()方法完成。
范例：强制性清空缓冲区
package org.lxh.demo12.chariodemo;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class WriterDemo04 {
public static void main(String[] args) throws Exception { // 异常抛出不处理
// 第1步：使用File类找到一个文件
File f = new File("d:" + File.separator + "test.txt");// 声明File
对象
// 第2步：通过子类实例化父类对象
Writer out = null;
// 准备好一个输出的对象
out = new FileWriter(f);
// 通过对象多态性进行实例化
// 第3步：进行写操作
String str = "Hello World!!!";
// 准备一个字符串
out.write(str);
// 将内容输出
out.flush();
// 强制性清空缓冲区中的内容
// 第4步：关闭输出流
// out.close();
// 此时没有关闭
}
} 程序运行结果：
此时，文件中已经存在了内容，更进一步证明内容是保存在缓冲区的。这一点在读者日后的开发中要特别引起注意。
提问：使用字节流好还是字符流好？
学习完字节流和字符流的基本操作后，已经大概地明白了操作流程的各个区别，那么在开发中是使用字节流好还是字符流好呢？
回答：使用字节流更好。
在回答之前，先为读者讲解这样的一个概念，所有的文件在硬盘或在传输时都是以字节的方式进行的，包括图片等都是按字节的方式存储的，而字符是只有在内存中才会形成，所以在开发中，字节流使用较为广泛。
字节流是指InputStream/OutputStream及其子类，字符流是指Reader/Writer及其子类。这两类I/O流的class hierarchy基本上是对等的，InputStreamReader/OutputStreamWriter是InputStream/OutputStream和Reader/Writer之间的桥梁。
InputStream/OutputStream
Java字节流，InputStream是所有字节输入流的祖先，而OutputStream是所有字节输出流的祖先。
读取文件: FileInputStream fileInputStream = new FileInputStream("d:/text.txt");
写入文件: FileOutputStream fileOutputStream = new FileOutputStream("d:/text.txt");
InputSteamReader/OutputStreamWriter
字节流转换成字符流可以用 InputSteamReader OutputStreamWriter
/输入字节流转换成InputStreamReader
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
//输出字节流转换成OutputStreamWriter
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream);
BufferedReader/BufferedWriter
BufferdReader BufferedWriter 他们具有缓冲区
//InputStreamReader 转换成带缓存的bufferedReader
BufferedReader bufferedReader = new BufferedReader(inputSteamReader);
可以把读出来的内容赋值给字符
String ss = new String();
String s;
while((s = bufferedReader.readLine())!=null){
ss += s;
}
//outputStreamWriter转换成带缓存的bufferedWriter
BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
bufferedWriter.write(s);
DataOutputStream/DataOutputStream
包装类DataOutputStream、DataInputStream为我们提供了多种对文件的写入和读取方法，
如writeBoolean(),writeUTF()，writeChar，writeByte()，writeDouble()等和对应的read方法，
import java.io.*;
public class TestDataStream {
public static void main(String[] args) throws Exception {
FileOutputStream fos=new FileOutputStream("data.txt");
BufferedOutputStream bos=new BufferedOutputStream(fos);
DataOutputStream dos=new DataOutputStream(bos);
FileInputStream fis=new FileInputStream("data.txt");
BufferedInputStream bis=new BufferedInputStream(fis);
DataInputStream dis=new DataInputStream(bis);
String str="你好hi";
dos.writeUTF(str); //按UTF-8格式写入
dos.writeChars(str); //按字符写入
//按字节写入有两种方法，第一种方法只能适应无汉字的情况；
//因为方法1在写入时会把所有的字符都按1个字节写入，而汉字的表示需要2个字节，
//这就造成了数据的丢失，读入时就会出现乱码。
//而方法2在将字符串转换为字节数组时就把汉字字符变为了2个字节，
//写入文件的时候也会按2个字节的文字写入，这样读取的时候就不会出现问题
dos.writeBytes(str);//方法1：将整个字符串按字节写入
byte[] b=str.getBytes();
dos.write(b); //方法2：将字符串转换为字节数组后再逐一写入
dos.close();
//按UTF-8格式读取
System.out.println(dis.readUTF());
//字符读取
char [] c=new char[4];
for(int i=0;i<4;i++){
c[i]=dis.readChar(); //读取4个字符
}
System.out.print(new String(c,0,4));
System.out.println();
//字节读取
byte [] b1=new byte[4];
dis.read(b1); //读取4个字节
System.out.print(new String(b1,0,4));//输出时会出现乱码
System.out.println();
byte [] b2=new byte[1024];
int len=dis.read(b2); //按字节读取剩余的内容
System.out.println(new String(b2,0,len));
}
}输出结果为：
你好hi
你好hi
`}hi
你好hi
注意1：一般情况下在读入时尽量按照写入时的格式进行读取，
否则有可能会出现显示乱码或程序出现异常。
如首先写入文件用的是writeUTF()，在读取的时候如果不是用readUTF()就会出现乱码，
如果readUTF()读取的内容不是UTF-8格式的，程序就会抛出异常。
注意2：如程序中注释所说，对于出现汉字字符的情况不能用writeBytes()，这会在写入文件时丢弃汉字字符的第一个字节从而在读取时出现错误。
注意3：所有的读取方法都是共享一个位置指示器的，即在前面的read方法执行后，后面再执行其他read方法都是从上一个read方法读取到的位置开始向后读取的。如开始执行了1次readByte()后面的readChar是从第2个字节开始读的。
扫一扫
459
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
