Question

JAVA问题

请问Buffer, Data等输入输出流的类型怎么区分啊

Answer 1

大多初学者对java I/O系统提供了如此多的类而感到不知所错，本文中将会做一下梳理
流的概念
流（stream）的概念源于UNIX中的管道（pipe）的概念。在UNIX中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等。
一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。
流的方向是重要的，根据流的方向，流可以分为两类：输入流和输出流。用户可以从输入流中读取信息，但不能写它。相反，对输出流，只能往往输入流写，而不能读取。其实输入/输出是想对于内存来说的。
实际上，流的源端和目的端可简单地看成是字节的生产者和消费者，对于输入流，可不必关心它的源端是什么，只要简单地从流中读数据，而对输出流，也可不知道它的目的端，只是简单地往流中写数据。
java.io包中的类对应两类流，一类流直接从指定的位置（如磁盘文件或内存区域）读或写，这类流称为结点流，其他的流则称为过滤流（包装流）
过滤流：一些流可以从文件以及其他地方接收字节，另一些流可以将字节组合成更有用的数据类型。将一个已经存在的流传递给另一个流的构造方法，将这两种流结合起来，结合后的流被称为过滤流。
过滤器输入流往往是以其它输入流作为它的输入源，经过过滤或处理后再以新的输入流的形式提供给用户，过滤器输出流也类似。

java的常用输入、输出流
其实都是继承自4个抽象类，分别是
基于单字节的InputStream,OutputStream类
基于双字节的Unicode代码单元的 Reader， Writer类
一旦打开输入流后，程序就可从输入流串行地读数据。
从输入流读数据的过程一般如下：
open a stream
while more information
read information
close the stream

类似地，程序也能通过打开一个输出流并顺序地写入数据来将信息送至目的端。
往输出流写数据的过程一般如下：
open a stream
while more information
write information
close the stream
java.io包中的stream类根据它们操作对象的类型是字符还是字节可分为两大类： 字符流和字节流。
InputStream,OutputStream类仅仅读取和写入单个的字节和字节数组，它们没有读取和写入字符串和数值的方法。
由于以字节为单位的流处理存储为Unicode码的信息很不方便（Unicode的每个代码单元使用了两个字节），所以有了一个专门的类层次来处理Unicode字符，这些类继承于抽象类Reader和Writer。

1.1 以字节为导向的stream

以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。以字节为导向的stream包括下面几种类型：
1。input stream：
1) ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用
2) StringBufferInputStream：把一个String对象作为InputStream ---已过时。 此类未能正确地将字符转换为字节。从 JDK 1.1 开始，从字符串创建流的首选方法是通过 StringReader 类进行创建。
3) FileInputStream：把一个文件作为InputStream，实现对文件的读取操作
4) PipedInputStream：实现了pipe的概念，主要在线程中使用
5) SequenceInputStream：把多个InputStream合并为一个InputStream
2。Out stream
1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
2) FileOutputStream：把信息存入文件中
3) PipedOutputStream：实现了pipe的概念，主要在线程中使用
4) SequenceOutputStream：把多个OutStream合并为一个OutStream
1.2 以Unicode字符为导向的stream
以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。以Unicode字符为导向的stream包括下面几种类型：
1)。Input Stream
1) CharArrayReader：与ByteArrayInputStream对应
2) StringReader：与StringBufferInputStream对应
3) FileReader：与FileInputStream对应
4) PipedReader：与PipedInputStream对应
2。Out Stream
1) CharArrayWrite：与ByteArrayOutputStream对应
2) StringWrite：无与之对应的以字节为导向的stream
3) FileWrite：与FileOutputStream对应
4) PipedWrite：与PipedOutputStream对应
以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现的功能相同，字是在操作时的导向不同。如CharArrayReader：和ByteArrayInputStream的作用都是把内存中的一个缓冲区作为InputStream使用，所不同的是前者每次从内存中读取一个字节的信息，而后者每次从内存中读取一个字符。

1.3 两种不限导向的stream之间的转换
InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个以字符为导向的stream。
InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集
OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

2. stream添加属性
2.1 “为stream添加属性”的作用
运用上面介绍的Java中操作IO的API，我们就可完成我们想完成的任何操作了。但通过FilterInputStream和FilterOutStream的子类，我们可以为stream添加属性。下面以一个例子来说明这种功能的作用。
如果我们要往一个文件中写入数据，我们可以这样操作：
FileOutStream fs = new FileOutStream(“test.txt”);
然后就可以通过产生的fs对象调用write()函数来往test.txt文件中写入数据了。但是，如果我们想实现“先把要写入文件的数据先缓存到内存中，再把缓存中的数据写入文件中”的功能时，上面的API就没有一个能满足我们的需求了。但是通过FilterInputStream和FilterOutStream的子类，为FileOutStream添加我们所需要的功能。

2.2 FilterInputStream的各种类型
2.2.1 用于封装以字节为导向的InputStream
1) DataInputStream：从stream中读取基本类型（int、char等）数据。
2) BufferedInputStream：使用缓冲区
3) LineNumberInputStream：会记录input stream内的行数，然后可以调用getLineNumber()和setLineNumber(int)
4) PushbackInputStream：很少用到，一般用于编译器开发
2.2.2 用于封装以字符为导向的InputStream
1) 没有与DataInputStream对应的类。除非在要使用readLine()时改用BufferedReader，否则使用DataInputStream
2) BufferedReader：与BufferedInputStream对应
3) LineNumberReader：与LineNumberInputStream对应
4) PushBackReader：与PushbackInputStream对应
2.3 FilterOutStream的各种类型
2.2.3 用于封装以字节为导向的OutputStream
1) DataIOutStream：往stream中输出基本类型（int、char等）数据。
2) BufferedOutStream：使用缓冲区
3) PrintStream：产生格式化输出
2.2.4 用于封装以字符为导向的OutputStream
1) BufferedWrite：与BufferedOutStream对应
2) PrintWrite：与 PrintStream对应
3. RandomAccessFile
1) 可通过RandomAccessFile对象完成对文件的读写操作
2) 在产生一个对象时，可指明要打开的文件的性质：r，只读；w，只写；rw可读写
3) 可以直接跳到文件中指定的位置

4. I/O应用的一个例子
import java.io.*;
public class TestIO{
public static void main(String[] args)
throws IOException{
//1.以行为单位从一个文件读取数据
/*当读取文件时，先把文件内容读到缓存中，当调用in.readLine()时，
再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。
*/
BufferedReader in = new BufferedReader(new FileReader("F:\\java\\TestIO.java"));
String s, s2 = new String();
while((s = in.readLine()) != null)
s2 += s + "\n";
in.close();

//1b. 接收键盘的输入
/*由于想以缓存字节读取方式从标准IO（键盘）中读取数据，所以要
先把标准IO（System.in）转换成字符导向的stream，再进行BufferedReader封装。
*/
BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter a line:");
System.out.println(stdin.readLine());

//2. 从一个String对象中读取数据
/*
要以字符的形式从一个String对象中读取数据，所以要产生一个StringReader类型的stream。
*/
StringReader in2 = new StringReader(s2);
int c;
while((c = in2.read()) != -1)
System.out.println((char)c);
in2.close();

//3. 从内存取出格式化输入
//把内存中的一个缓冲区作为DataInputStream使用

try{
DataInputStream in3 = new DataInputStream(new ByteArrayInputStream(s2.getBytes()));
while(true)
System.out.println((char)in3.readByte());
}catch(EOFException e){
System.out.println("End of stream");
}

//4. 输出到文件
/*对String对象s2读取数据时，先把对象中的数据存入缓存中，再从缓冲中进行读取；对TestIO.out文件进行操作时，
先把格式化后的信息输出 到缓存中，再把缓存中的信息输出到文件中。
*/
try{
BufferedReader in4 = new BufferedReader(new StringReader(s2));
PrintWriter out1 = new PrintWriter(new BufferedWriter(new FileWriter("F:\\java\\ TestIO.out")));
int lineCount = 1;
while((s = in4.readLine()) != null)
out1.println(lineCount++ + "：" + s);
out1.close();
in4.close();
} catch(EOFException ex){
ystem.out.println("End of stream");
}

//5. 数据的存储和恢复
/*对Data.txt文件进行输出时，是先把基本类型的数据输出屋缓存中，再把缓存中的数据输出到文件中；对文件进行读取操作时，先把文件中的数据读取到缓存中，再从缓存中以基本类型的形式进行读取。注意in5.readDouble()这一行。因为写入第一个writeDouble()，所以为了正确显示。也要以基本类型的形式进行读取。
*/
try{
DataOutputStream out2 = new DataOutputStream(new BufferedOutputStream( new FileOutputStream("F:\\java\\ Data.txt")));
out2.writeDouble(3.1415926);
out2.writeChars("\nThas was pi:writeChars\n");
out2.writeBytes("Thas was pi:writeByte\n");
out2.close();
DataInputStream in5 = new DataInputStream( new BufferedInputStream(new FileInputStream("F:\\java\\ Data.txt")));
BufferedReader in5br = new BufferedReader( new InputStreamReader(in5));
System.out.println(in5.readDouble());
System.out.println(in5br.readLine());
System.out.println(in5br.readLine());
} catch(EOFException e){
System.out.println("End of stream");
}

//6. 通过RandomAccessFile操作文件
//通过RandomAccessFile类对文件进行操作。
RandomAccessFile rf =new RandomAccessFile("F:\\java\\ rtest.dat", "rw");
for(int i=0; i<10; i++)
rf.writeDouble(i*1.414);
rf.close();

rf = new RandomAccessFile("F:\\java\\ rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();

rf = new RandomAccessFile("F:\\java\\ rtest.dat", "rw");
rf.seek(5*8);
rf.writeDouble(47.0001);
rf.close();

rf = new RandomAccessFile("F:\\java\\ rtest.dat", "r");
for(int i=0; i<10; i++)
ystem.out.println("Value " + i + "：" + rf.readDouble());
rf.close();
}
}

一、概念Java中对文件的操作是以流的方式进行的。流是Java内存中的一组有序数据序列。Java将数据从源（文件、内存、键盘、网络）读入到内存中，形成了流，然后将这些流还可以写到另外的目的地（文件、内存、控制台、网络），之所以称为流，是因为这个数据序列在不同时刻所操作的是源的不同部分。二、分类流的分类，Java的流分类比较丰富，刚接触的人看了后会感觉很晕。流分类的方式很多：1、按照输入的方向分，输入流和输出流，输入输出的参照对象是Java程序。2、按照处理数据的单位不同分，字节流和字符流，字节流读取的最小单位是一个字节（1byte=8bit），而字符流一次可以读取一个字符（1char = 2byte = 16bit）。3、按照功能的不同分，分节点流和处理流，节点流是直接从一个源读写数据的流（这个流没有经过包装和修饰），处理流是在对节点流封装的基础上的一种流，FileInputStream是一个接点流，可以直接从文件读取数据，但是BufferedInputStream可以包装FileInputStream，使得其有缓冲功能。其实除了以上三种分类外，还有一些常常听到的一些分类比如：对象流、缓冲流、压缩流、文件流等等。其实都是节点流和处理流的子分类。当然你也可以创建新的流类型，只要你需要。三、流分类的关系不管流的分类是多么的丰富和复杂，其根源来自于四个基本的类。这个四个类的关系如下：

字节流：

字节流是最基本的流，文件的操作、网络数据的传输等等都依赖于字节流。而字符流常常用于读取文本类型的数据或字符串流的操作等等。 关于字节流的API，没什么好说的，看看就知道了。这里挑几个关键点：一、InputStream的API1、public int read()从输入流读取下一个数据字节。返回 0 到 255 范围内的 int 字节值。如果因已到达流末尾而没有可用的字节，则返回值 -1。2、public int read(byte[] b)从输入流中读取一定数量的字节并将其存储在缓冲区数组 b 中。以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值 -1；否则，至少可以读取一个字节并将其存储在 b 中。此方法等同于read(b, 0, b.length)3、public int read(byte[] b, int off, int len)将输入流中最多 len 个数据字节读入字节数组。尝试读取多达 len 字节，但可能读取较少数量。以整数形式返回实际读取的字节数。如果由于已到达流末尾而不再有数据，则返回 -1。参数：b - 读入数据的缓冲区。off - 在其处写入数据的数组 b 的初始偏移量。len - 要读取的最大字节数。二、OutputStream的API1、public void write(int b)将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。2、public void write(byte[] b)将 b.length 个字节从指定的字节数组写入此输出流。write(b) 的常规协定是：应该与调用 write(b, 0, b.length) 的效果完全相同。3、public void write(byte[] b, int off, int len)将指定字节数组中从偏移量 off 开始的 len 个字节写入此输出流。write(b, off, len) 的常规协定是：将数组 b 中的某些字节按顺序写入输出流；元素 b[off] 是此操作写入的第一个字节，b[off+len-1] 是此操作写入的最后一个字节。参数：b - 数据。off - 数据中的初始偏移量。len - 要写入的字节数。4、public void flush()刷新此输出流并强制写出所有缓冲的输出字节。flush 的常规协定是：如果此输出流的实现已经缓冲了以前写入的任何字节，则调用此方法指示应将这些字节立即写入它们预期的目标。三、几点原则1、不管是输入还是输出流，使用完毕后要close()，如果是带有缓冲区的输出流，应在关闭前调用flush()。2、应该尽可能使用缓冲区，来减少IO次数，以提高性能。3、能用字符流处理的不用字节流。四、例子下面是一个操作字节流的例子：要操作的文本文件x.txt);
fos = new FileOutputStream(\"C:\\\\xcopy.txt\");
long num = 0; //读取字节计数
int bt = 0; //每次读入字节内容
//当读入文件末尾时，读入数据的值为-1
//每次读入一个字节，存放到变量bt中，直到读完整个文件
while ((bt = fis.read()) != -1) {
// System.out.print(bt); //以数字的形式逐个输出文件的每个字节
System.out.print((char) bt); //以字母的形式逐个输出文件的每个字节
fos.write(bt); //将字节写入输出流中，实现文件的copy功能
num++;
}
System.out.println(\"读取的字节数为\" + num);
fis.close();
fos.close();
} catch (FileNotFoundException e) {
System.out.println(\"找不到指定的文件！\");
e.printStackTrace();
} catch (IOException e) {
System.out.println(\"文件读取时发生IO异常！\");
e.printStackTrace();
}
}

/**
* 缓冲的字节流测试
*/
public static void testBufferedStream() {
int buffer = 10; //缓冲大小
try {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(\"C:\\\\x.txt\"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(\"C:\\\\bf2.txt\"));
int bench = 0;
byte bts[] = new byte[buffer]; //创建字节流缓存
while ((bis.read(bts)) != -1) {
bos.write(bts); //将字节写入输出流中，实现文件的copy功能
bench++;
}
System.out.println(\"bench=\" + bench);
//将输入流缓冲区中的数据全部写出（千万记住)
bos.flush();
bis.close();
bos.close();
} catch (FileNotFoundException e) {
System.out.println(\"找不到指定的文件！\");
e.printStackTrace();
} catch (IOException e) {
System.out.println(\"文件读取时发生IO异常！\");
e.printStackTrace();
}
}

/**
* 字节流的选择读取测试
*/
public static void testSelectStream() {
OutputStream fos = null;
int buffer = 25;
try {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(\"C:\\\\x.txt\"));
fos = new FileOutputStream(\"C:\\\\testSelectStream.txt\");

byte bts[] = new byte[buffer]; //创建缓存
//从输入流的第5个字节开始，往后读取10个字节，存放到缓存bts中
//这个方法有个陷阱，缓存buffer的大小最小为“偏移量+要读取字节数”，在次最小应该为15，否则抛IndexOutOfBoundsException异常
bis.read(bts, 5, 10);
//将字节写入输出流中，实现文件的copy功能
fos.write(bts);

bis.close();
fos.close();
} catch (FileNotFoundException e) {
System.out.println(\"找不到指定的文件！\");
e.printStackTrace();
} catch (IOException e) {
System.out.println(\"文件读取时发生IO异常！\");
e.printStackTrace();
}
}
}注意了：1、缓冲的功能应该通过相应的缓冲流来包装原始流来实现，而不是自己连续多次数据，最后写到一个数组中，这是很愚昧的做法（但是还有很多人在用）。2、read(byte[] b, int off, int len)这个方法要好好体会了，往往和你想象的不一样。3、将读取的一个字节强制转换为char是不合适的，除非你想看看能输出什么。

字符流：

字符流的处理和字节流差不多，API基本上完全一样，就是计量单位不同。另外字符流还提供一些其他的处理流，比如按行读取流、字符串流等等。下面给个例子看看：
import java.io.*;/**
* 字符流测试
* @author 2008-8-27 22:16:44
*/
public class TestIOStream {
public static void main(String[] args) {
testReaderWriter();
testLineNumberReader();
} /**
* 带缓冲的字符流
*/
public static void testReaderWriter() {
int bufsize = 25;
try {
BufferedReader bufferedReader = new BufferedReader(new FileReader(new File(\"C:\\\\x.txt\")));
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(new File(\"C:\\\\xb.txt\"))); char buf[] = new char[bufsize]; //字符缓冲区
while (bufferedReader.read(buf) != -1) {
bufferedWriter.write(buf);
}
bufferedWriter.flush();
bufferedReader.close();
bufferedWriter.close(); } catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 按行读取的字符流
*/
public static void testLineNumberReader() {
try {
LineNumberReader lineNumberReader = new LineNumberReader(new BufferedReader(new FileReader(new File(\"C:\\\\x.txt\")))); String lineString; //行字符串变量
int x = 0; //行号
while ((lineString = lineNumberReader.readLine()) != null) {
x++;
System.out.println(\"行号：\" + x + \" >>>\" + lineString);
}
lineNumberReader.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

运行结果：
行号：1 >>>白日依山尽，黄河入海流。
行号：2 >>>欲穷千里目，更上一层楼。
行号：3 >>>
行号：4 >>>—— 王之涣《登鹳雀楼》

Answer 2

FileInputStream和FileOutputStream
节点流，用于从文件中读取或往文件中写入字节流。如果在构造FileOutputStream时，文件已经存在，则覆盖这个文件。

BufferedInputStream和BufferedOutputStream
过滤流，需要使用已经存在的节点流来构造，提供带缓冲的读写，提高了读写的效率。
DataInputStream和DataOutputStream
过滤流，需要使用已经存在的节点流来构造，提供了读写Java中的基本数据类型的功能。
PipedInputStream和PipedOutputStream
管道流，用于线程间的通信。一个线程的PipedInputStream对象从另一个线程的PipedOutputStream对象读取输入。要使管道流有用，必须同时构造管道输入流和管道输出流。

Answer 3

http://hi.baidu.com/javagarden/blog/item/be943df3ad6eafc30b46e02c.html