JAVA输入输出流--字节流篇(什么时候用哪个)

1流的概念

stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样，如下图：

在Java的IO中，所有的stream（包括Inputstream和Out stream）都包括两种类型：

(1)字节流

表示以字节为单位从stream中读取或往stream中写入信息，即io包中的inputstream类和outputstream类的派生类。通常用来读取二进制数据，如图象和声音。

(2)字符流

以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。

区别：

Reader和Writer要解决的，最主要的问题就是国际化。原先的I/O类库只支持8位的字节流，因此不可能很好地处理16位的Unicode字符流。Unicode是国际化的字符集(更何况Java内置的char就是16位的Unicode 字符)，这样加了Reader和Writer之后，所有的I/O就都支持Unicode了。此外新类库的性能也比旧的好。

但是，Read和Write并不是取代InputStream和OutputStream，有时，你还必须同时使用"基于byte的类"和"基于字符的类"。为此，它还提供了两个"适配器(adapter)"类。InputStreamReader负责将InputStream转化成Reader，而OutputStreamWriter则将OutputStream转化成Writer。实际上是通过byte[]和String来关联。在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的。

以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现的功能相同，只是在操作时的导向不同。

如 CharArrayReader和ByteArrayInputStream的作用都是把内存中的一个缓冲区作为InputStream使用，所不同的是前者每次从内存中读取一个字节的信息，而后者每次从内存中读取一个字符。

字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串；而字节流处理单元为1个字节，操作字节和字节数组，可用于任何类型的对象，包括二进制对象，但是不能直接处理Unicode字符。字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好。如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点。

2流的层次结构

java将读取数据对象称为输入流，能向其写入的对象叫输出流。

1)基于字节的输入流

●FileInputStream：把一个文件作为InputStream，从本地文件系统中

读取数据字节，实现对文件的读取操作

●ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使

用，从内存数组中读取数据字节

●ObjectInputStream：对象输入流。从文件中把对象读出来重新建立。

对象必须要实现Serializable接口。对象中的transient和static类型

的成员变量不会被读取和写入。

●PipedInputStream：实现了pipe的概念，从线程管道中读取数据字节，

主要在线程中使用。管道输入流是指一个通讯管道的接收端。一个线程

通过管道输出流发送数据，而另一个线程通过管道输入流读取数据，这

样可实现两个线程间的通讯

●SequenceInputStream：把多个InputStream合并为一个

InputStream，当到达流的末尾时从一个流转到另一个流，“序列输入

流”类允许应用程序把几个输入流连续地合并起来，并且使它们像单个输

入流一样出现。

●StringBufferInputStream：把一个String对象作为InputStream，

从字符串中读取数据字节

●FilterInputStream：过滤器流java.io.FilterInputStream，过滤器流

即能把基本流包裹起来，提供更多方便的用法。类的构造方法为

FilterInputStream(InputStream)，在指定的输入流之上，创建一个

输入流过滤器。常用的子类如下：

◆BufferedInputStream：缓冲区对数据的访问，以提高效率

◆DataInputStream：从输入流中读取基本数据类型，如int、float、

double或者甚至一行文本

◆LineNumberInputStream：在翻译行结束符的基础上，维护一个

计数器，该计数器表明正在读取的是哪一行。

◆PushbackInputStream：允许把数据字节向后推到流的首部

●System.in

从用户控制台读取数据字节

在System类中， in是InputStream类的静态对象，因此，out和err 可以引用PrintStream类的成员方法。如：System.in.read()。

2)基于字节的输出流

●FileOutputStream：把信息存入文件中

●ByteArrayOutputStream：把信息存入内存中的一个缓冲区中，该类实

现一个以字节数组形式写入数据的输出流

●PipedOutputStream：实现了pipe的概念，主要在线程中使用。管道

输出流是指一个通讯管道的发送端。一个线程通过管道输出流发送数

据，而另一个线程通过管道输入流读取数据，这样可实现两个线程间的

通讯。

●SequenceOutputStream：把多个OutStream合并为一个

OutStream

●FilterOutputStream：类似于FilterInputStream，OutputStream也

提供了过滤器输出流。

●ObjectOutputStream：对象输出流。对象必须要实现Serializable接

口。对象中的transient和static类型的成员变量不会被读取和写入。

●System.out

输出数据字节到用户控制台

在System类中，out和err是PrintStream类的静态对象，因此，out 和err可以引用PrintStream类的成员方法。如：System.out.write (int

a)。

3)基于字符的输入流

●CharArrayReader：与ByteArrayInputStream对应，从字符数组中

读取数据

●StringReader：与StringBufferInputStream对应，从字符数组中读

取数据

●FileReader：与FileInputStream对应，从本地文件系统中读取字符序

列

●PipedReader：与PipedInputStream对应，从线程管道中读取字符序

列

●InputStreamReader：InputStreamReader是从输入流中读取数据，

连接输入流于读取器。如： new InputStreamReader(System.in)

●BufferedReader：缓冲数据的访问，以提高效率

◆LineNumberReader（BufferedReader的子类）：维护一个计数

器，该计数器表明正在读取的是哪一行。

●FilterReader（抽象类）：提供一个类创建过滤器时可以扩展这个类

◆PushbackReader（FilterReader的子类）：允许把文本数据推回

到读取器的流中。

这些过滤器读取器都可以传入一个Reader作为构造方法的参数。

4)基于字符的输出流

●CharArrayWrite：与ByteArrayOutputStream对应

●StringWrite：无与之对应的以字节为导向的stream

●FileWrite：与FileOutputStream对应

PipedWrite：与PipedOutputStream对应

3InputStream类

Inputstream类和Outputstream类都为抽象类，不能创建对象，可以通过子类来实例化。

InputStream是输入字节数据用的类，所以InputStream类提供了3种重载的read方法。Reader也有完全相同的3个read接口。Inputstream类中的常用方法：

1)public abstract int read( )：读取一个byte的数据，返回读到的数据

(高位补0的int类型值),如果返回-1，表示读到了输入流的末尾。

2)public int read(byte b[ ])：读取b.length个字节的数据放到b数

组中。返回值是读取的字节数, 如果返回-1，表示读到了输入流的末尾。

该方法实际上是调用下一个方法实现的。

3)public int read(byte b[ ], int off, int len)：从输入流中最多读取

len个字节的数据，存放到数组b中，返回实际读取的字节数。如果返

回-1，表示读到了输入流的末尾。off指定在数组b中存放数据的起始

偏移位置。

4)public int available( )：返回输入流中可以读取的字节数。注意：若输

入阻塞，当前线程将被挂起，如果InputStream对象调用这个方法的

话，它只会返回0，这个方法必须由继承InputStream类的子类对象调

用才有用。

5)public long skip(long n)：忽略输入流中的n个字节，返回值是实际

忽略的字节数, 跳过一些字节来读取。

6)public int close( ) ：我们在使用完后，必须对我们打开的流进行关闭。

7)void mark(int readlimit) ：在输入流的当前位置放置一个标记，如果

读取的字节数多于readlimit设置的值，则流忽略这个标记。在

IutputStream类中实际是一个空实现。

8)void reset() ：返回到上一个标记。

9)boolean markSupported() ：测试当前流是否支持mark和reset方

法。如果支持，返回true，否则返回false。在IutputStream类中实

际是一个空实现。

4OutputSteam类

OutputStream提供了3个write方法来做数据的输出，这个是和InputStream是相对应的，Writer同样提供了相同的三个write方法。

1)public abstract void write(int b) ：先将int转换为byte类型，把

低字节写入到输出流中。

2)public void write(byte b[ ])：将参数b中的字节写到输出流。

3)public void write(byte b[ ], int off, int len) ：将参数b的从偏

移量off开始的len个字节写到输出流。

4)public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区。

只对使用了缓冲的流类起作用。在OutputStream类中实际是一个空实

现。

5)public void close( ) : 关闭输出流并释放与流相关的系统资源。

注意：

1)上述各方法都有可能引起异常。

2)InputStream和OutputStream都是抽象类，不能创建这种类型的对

象。

5FileInputStream和FileOutputStream 5.1FileInputStream

FileInputStream类是InputStream类的子类，用来处理以文件作为数据输入源的数据流。使用方法：

方式1：

File fin=new File("d:/abc.txt");

FileInputStream in=new FileInputStream(fin);

方式2：

FileInputStream in=new FileInputStream("d: /abc.txt");

方式3：

构造函数将 FileDescriptor()对象作为其参数。

FileDescriptor() fd=new FileDescriptor();

FileInputStream f2=new FileInputStream(fd);

从指定文件中读出数据：

view plaincopy to clipboardprint?

1.import java.io.*;

https://www.360docs.net/doc/1d5620346.html,ss StreamTest{

3.public static void main(String[] args)throws Exception{

4. FileInputStream fis=new FileInputStream("testoutput.txt");

5.byte[] buf=new byte [100];

6.int len=fis.read(buf);

7. System.out.println(new String(buf,0,len));//由于buf是大小为100的缓冲

区，为了输出有效字符使用String类的构造方法

String(byte[] bytes, int offset, int length)实现输出

8. fis.close();

9. }

10.}

5.2FileOutputStream

FileOutputStream类用来处理以文件作为数据输出目的数据流；一个表示文件名的字符串，也可以是File或FileDescriptor对象。

创建一个文件流对象有两种方法：

方式1：

File f=new File("d:/abc.txt");

FileOutputStream out=new FileOutputStream (f);

方式2：

FileOutputStream out=new

FileOutputStream("d:/abc.txt");

方式3：

构造函数将 FileDescriptor()对象作为其参数。

FileDescriptor() fd=new FileDescriptor();

FileOutputStream f2=new FileOutputStream(fd);

方式4：

构造函数将文件名作为其第一参数，将布尔值作为第二参数。

FileOutputStream f=new FileOutputStream("d:/abc.txt",true);

注意：

1)文件中写数据时，若文件已经存在，则覆盖存在的文件；

2)文件的读/写操作结束时，应调用close方法关闭流。

向指定文件写入数据：

view plaincopy to clipboardprint?

1.import java.io.*;

2.class StreamTest{

3.public static void main(String[] args)throws Exception{

4. FileOutputStream fos=new FileOutputStream("testoutput.txt");

5. fos.write("Hello World".getBytes ());

6. fos.close();

7. }

8.}

程序中使用到FileOutputStream类的方法void write(byte[] b) ，所以从写入字符串" Hello World "通过String类的方法getBytes()得到字节数组b，成功进行写入。

6ObjectOutputStream和ObjectInputStream

ObjectOutputStream和ObjectInputStream可以利用对象流对对象进行序列化。

在一个程序运行的时候，其中的变量数据是保存在内存中的，一旦程序结束这些数据将不会被保存，一种解决的办法是将数据写入文件，而Java中提供了一种机制，它可以将程序中的对象写入文件，之后再从文件中把对象读出来重新建立。这就是所谓的对象序列化Java中引入它主要是为了RMI（Remote Method Invocation）和Java Bean所用，不过在平时应用中，它也是很有用的一种技术。

所有需要实现对象序列化的对象必须首先实现Serializable接口。下面看一个例子：

view plaincopy to clipboardprint?

1.import java.io.*;

2.import java.util.*;

3.public class Logon implements Serializable {

4.private Date date = new Date();

5.private String username;

6.private transient String password;

7.Logon(String name, String pwd){

8. username = name;

9. password = pwd;

10. }

11.public String toString(){

12. String pwd = (password == null) ? "(n/a)":password;

13.return"logon info: \n " + "username: " + username + "\n date:

" + date + "\n password: " + pwd;

14. }

15.public static void main(String[] args)throws IOException, ClassNotFou

ndException {

16. Logon a = new Logon("Morgan", "morgan83");

17. System.out.println("logon a = " + a);

18. ObjectOutputStream o = new ObjectOutputStream( new FileOutputS

tream("Logon.out"));

19. o.writeObject(a);

20. o.close();

21.int seconds = 5;

22.long t = System.currentTimeMillis() + seconds * 1000;

23.while(System.currentTimeMillis()

24. ObjectInputStream in = new ObjectInputStream(new FileInputStre

am("Logon.out"));

25. System.out.println("Recovering object at " + new Date());

26. a = (Logon)in.readObject();

27. System.out.println("logon a = " + a);

28. }

29.}

类Logon是一个记录登录信息的类，包括用户名和密码。首先它实现了接口Serializable，这就标志着它可以被序列化。之后再main方法里ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("Logon.out"));新建一个对象输出流包装一个文件流，表示对象序列化的目的地是文件Logon.out。然后用方法writeObject开始写入。想要还原的时候也很简单ObjectInputStream in = new ObjectInputStream(new FileInputStream("Logon.out"));新建一个对象输入流以文件流Logon.out为参数，之后调用readObject方法就可以了。

需要说明一点，对象序列化有一个神奇之处就是，它建立了一张对象网，将当前要序列化的对象中所持有的引用指向的对象都包含起来一起写入到文件，更为奇妙的是，如果你一次序列化了好几个对象，它们中相同的内容将会被共享写入。这的确是一个非常好的机制。它可以用来实现深层拷贝。

关键字transient在这里表示当前内容将不被序列化，比如例子中的密码，需要保密，所以没有被写入文件。

7PipedInputStream和PipedOutputStream

PipedInputStream和PipedOutputStream分别从InputStream类和OutputStream类继承，因此它们并不是过滤流类。

管道流，用于线程间的通信。一个线程的PipedInputStream对象从另一个线程的 PipedOutputStream对象读取。要使管道流有用，必须同时构造管道输入流和管道输出流。

利用线程生产者和消费者问题：

view plaincopy to clipboardprint?

1.import java.io.*;

2.class PipedStreamTest{

3.public static void main(String[] args){

4. PipedOutputStream pos=new PipedOutputStream();

5. PipedInputStream pis=new PipedInputStream();

6.try{

7. pos.connect(pis);

8.new Producer(pos).start();

9.new Consumer(pis).start();

10. }catch(Exception e){

11. e.printStackTrace();

12. }

13. }

14.}

15.

16.class Producer extends Thread{

17.private PipedOutputStream pos;

18. Producer(PipedOutputStream pos){

19.this.pos=pos;

20. }

21.public void run(){

22.try{

23. pos.write("Hello,My friends!".getBytes());

24. pos.close();

25. }catch(Exception e){

26. e.printStackTrace();

27. }

28. }

29.}

30.class Consumer extends Thread{

31.private PipedInputStream pis;

32. Consumer(PipedInputStream pis){

33.this.pis=pis;

34. }

35.public void run(){

36.try{

37.byte[] buf=new byte[100];

38.int len=pis.read(buf);

39. System.out.println(new String(buf,0,len));

40. pis.close();

41. }catch(Exception e){

42. e.printStackTrace();

43. }

44. }

45.}

8FilterInputStream和FilterOutputStream

java的流类提供了结构化方法，如，底层流和高层过滤流。

而高层流不是从输入设备读取，而是从其他流读取。同样高层输出流也不是写入输出设备，而是写入其他流。

使用“分层对象(layered objects)”，为单个对象动态地，透明地添加功能的做法，被称为Decorator Pattern。Decorator模式要求所有包覆在原始对象之外的对象，都必须具有与之完全相同的接口。这使得decorator的用法变得非常的透明--无论对象是否被decorate过，传给它的消息总是相同的。这也是Java I/O类库要有“filter(过滤器)”类的原因：抽象的“filter”类是所有decorator的基类。Decorator模式常用于如下的情形：如果用继承来解决各种需求的话，类的数量会多到不切实际的地步。Java的I/O类库需要提供很多功能的组合，于是decorator模式就有了用武之地。

为InputStream和OutputStream定义decorator类接口的类，分别是FilterInputStream和FilterOutputStream。

通过FilterInputStream和FilterOutStream的子类，我们可以为stream 添加属性。下面以一个例子来说明这种功能的作用。

如果我们要往一个文件中写入数据，我们可以这样操作：

FileOutStream fs = new FileOutStream(“test.txt”);

然后就可以通过产生的fs对象调用write()函数来往test.txt文件中写入数据了。但是，如果我们想实现“先把要写入文件的数据先缓存到内存中，再把缓存中的数据写入文件中”的功能时，上面的API就没有一个能满足我们的需求了。但是通过FilterInputStream和 FilterOutStream的子类，为FileOutStream 添加我们所需要的功能。

8.1FilterInputStream

8.2FilterOutputStream

8.3DataInputStream和

DataOutputStream

DataInputStream类对象可以读取各种类型的数据。

DataOutputStream类对象可以写各种类型的数据；

创建这两类对象时，必须使新建立的对象指向构造函数中的参数对象。例如：FileInputStream in=new FileInputStream("d:/test.txt");

DataInputStream din=new DataInputStream(in);

向指定文件中写入数据：

view plaincopy to clipboardprint?

1.import java.io.*;

2.class StreamTest{

3.public static void main(String[] args)throws Exception{

4. FileOutputStream fos=new FileOutputStream("d:/test.txt");

5. BufferedOutputStream bos=new BufferedOutputStream(fos);

6. DataOutputStream dos=new DataOutputStream(bos);

7.byte b=3;

8.int i=100;

9.boolean bool=false;

10.char c='k';

11.float f=45.77f;

12. dos.writeByte(b);

13. dos.writeInt(i);

14. dos.writeBoolean(bool);

15. dos.writeChar(c);

16. dos.writeFloat(f);

17. dos.close();

18. }

19.}

从指定文件中读出数据：

view plaincopy to clipboardprint?

1.import java.io.*;

2.class StreamTest{

3.public static void main(String[] args)throws Exception{

4. FileInputStream fis=new FileInputStream("d:/test.txt");

5. BufferedInputStream bis=new BufferedInputStream(fis);

6. DataInputStream dis=new DataInputStream(bis);

7. System.out.println(dis.readByte());

8. System.out.println(dis.readInt());

9. System.out.println(dis.readBoolean());

10. System.out.println(dis.readChar());

11. System.out.println(dis.readFloat());

12. dis.close();

13. }

14.}

8.4BufferInputStream和

BufferOutputStream

允许程序在不降低系统性能的情况下一次一个字节的从流中读取数据。

BufferInputstream定义了两种构造函数

（1）BufferInputStream b= new BufferInputstream(in);

（2）BufferInputStream b=new BufferInputStream(in,size)

第二个参数表示指定缓冲器的大小。

同样BufferOutputStream也有两种构造函数。一次一个字节的向流中写数据。

向指定文件中写入数据：

view plaincopy to clipboardprint?

1.import java.io.*;

2.class StreamTest{

3.public static void main(String[] args)throws Exception{

4. FileOutputStream fos=new FileOutputStream("testBuffer.txt");

5. BufferedOutputStream bos=new BufferedOutputStream(fos);

6. bos.write("Hello BufferedOutputStream!".getBytes());

7. bos.close();

8. }

9.}

如果不加bos.close();语句，则运行后打开testBuffer.txt文件会查看不到内容，这是因为我们将数据写入了缓冲区，只有结束程序时才写入到指定文件中。bos.close();实现立即写入到指定文件，不同的是这样如果想要继续写入就不用再次打开文件了。

从指定文件中读出数据：

view plaincopy to clipboardprint?

1.import java.io.*;

2.class StreamTest{

3.public static void main(String[] args)throws Exception{

4. FileInputStream fis=new FileInputStream("d:/test.txt");

5. BufferedInputStream bis=new BufferedInputStream(fis);

6.byte[] buf=new byte [100];

7.int len = bis.read(buf);

8. System.out.println(new String(buf,0,len));

9. bis.close();

10. }

11.}

8.5Printstream

用于写入文本或基本类型

两种构造函数方法：

PrintStream ps=new PrintStream(out);

PrintStream ps=new PrintStream(out, autoflush)

第二个参数为布尔值，控制每次输出换行符时java是否刷新输出流。

9Java IO 的一般使用原则

一、按数据来源（去向）分类：

1 、是文件： FileInputStream, FileOutputStream(字节流),FileReader, FileWriter(字符流)

2 、是 byte[] ： ByteArrayInputStream, ByteArrayOutputStream(字节流)

3 、是 Char[]: CharArrayReader, CharArrayWriter(字符流)

4 、是 String: StringBufferInputStream, StringBufferOuputStream (字节流)StringReader, StringWriter(字符流)

5 、网络数据流： InputStream, OutputStream(字节流), Reader, Writer( 字符流 )

二、按是否格式化输出分：

1 、要格式化输出： PrintStream, PrintWriter

三、按是否要缓冲分：

1 、要缓冲： BufferedInputStream, BufferedOutputStream(字节流), BufferedReader, BufferedWriter(字符流)

四、按数据格式分：

1 、二进制格式（只要不能确定是纯文本的）: InputStream, OutputStream 及其所有带 Stream 结束的子类

2 、纯文本格式（含纯英文与汉字或其他编码方式）:Reader, Writer 及其所有带 Reader, Writer 的子类

五、按输入输出分：

1 、输入： Reader, InputStream 类型的子类

2 、输出： Writer, OutputStream 类型的子类

六、特殊需要：

1 、从 Stream 到 Reader,Writer 的转换类： InputStreamReader, OutputStreamWriter

2 、对象输入输出： ObjectInputStream, ObjectOutputStream

3 、进程间通信： PipeInputStream, PipeOutputStream, PipeReader, PipeWriter

4 、合并输入： SequenceInputStream

5 、更特殊的需要： PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader

决定使用哪个类以及它的构造进程的一般准则如下（不考虑特殊需要）：首先，考虑最原始的数据格式是什么：原则四

第二，是输入还是输出：原则五

第三，是否需要转换流：原则六第 1 点

第四，数据来源（去向）是什么：原则一

第五，是否要缓冲：原则三（特别注明：一定要注意的是 readLine() 是否有定义，有什么比 read, write 更特殊的输入或输出方法）

第六，是否要格式化输出：原则二