JAVA之IO类

一、流的概念

在Java中，可以提供字节序列的对象，或者可以接收字节序列的对象，都可以抽象成流。能向程序中提供字节序列，即可以从其中读入字节序列，这样的对象显然就是输入流。相反的，能够接收程序送来的字节序列，也就是可以向其中写入字节序列，就是输出流。

InputStream和OutputStream类分别是字节输入/输出流继承体系的基类。

字节流都是以字节为单位读写的，而Java中字符采用的是Unicode形式，一个Unicode元码是两个字节，不同字符的字节数目并不一致。有时候我们不关心字节与字符的转化，希望读写都按字符为单位进行，就可以使用字符流类家族，Reader和Writer是字符输入/输出流的基类。

1、基于字节操作的I/O接口：InputStream和OutputStream
2、基于字符操作的I/O接口：Writer和Reader
3、基于磁盘操作的I/O接口：File
4、基于网络操作的I/O接口：Socket（不在java.io包下）

二、流的抽象类

java.io.InputStream

abstract int read()
从数据中读入一个字节，并返回该字节（0-255）。该方法碰到流结尾
时返回-1
int read(byte[] b)
int read(byte[] b,int off, int len)试图读入多个字节，存入字节数组b，返回实际读入的字节数。
该方法碰到流结尾时返回-1
int available()
返回在不阻塞的情况下，可以读入或者跳过（skip）的字节数
void close()
long skip(long n)关闭这个输入流
在输入流跳过n个字节例子：这时候读入三个字节，分别存入到buffer[1] buffer[2] buffer[3].其他元素保持不变

InputStream is = null;          byte[] buffer = new byte[6];          //char c;                    try {              is = new FileInputStream("test.txt");              is.read(buffer, 1, 3);              //System.out.println("available: " + is.available());                            for (byte b : buffer) {                  System.out.println((char)b);              }                            System.out.println((char)buffer[1]);  

java.io.OutputStream

abstract int write(int n)
写出一个字节的数据（将数据n写到输出流）int write(byte[] b)
int write(byte[] b,int off, int len)写出数组b中的数据（将数组b中的数据写到输出流）int flush()
冲刷输出流
void close()冲刷并关闭输出流
Reader和Writer的大部分方法与InputStream和OutputStream类似，只不过参数类型从byte变成了char

java.io.Reader

int read()
返回一个Unicode码元(0-65535)，或者碰到结尾返回-1
int read(char[] b)
abstract int read(char[] b,int off,int len)
 

java.io.Writer

void write(int c)
写出一个码元（从c写到输出流）void write(char [] b)
abstract void write(char[] b, int off, int len)

void write(String str)
void write(String str, int off, int len) 

三、流的常见类

 ByteArrayInputStream -- 把内存中的一个缓冲区作为 InputStream 使用 .

construct---

(A)ByteArrayInputStream(byte[]) 创建一个新字节数组输入流（ ByteArrayInputStream ），它从指定字节数组中读取数据（ 使用 byte 作为其缓冲区数组）

(B)ByteArrayInputStream(byte[], int, int) 创建一个新字节数组输入流，它从指定字节数组中读取数据。

method---

方法都是实现了InputStream方法。

StringBufferInputStream -- 把一个 String 对象作为 InputStream .

construct---  

StringBufferInputStream(String) 据指定串创建一个读取数据的输入流串。

method---

实现了InputStream中的部分方法

注释：不推荐使用 StringBufferInputStream 方法。 此类不能将字符正确的转换为字节。

同 JDK 1.1 版中的类似，从一个串创建一个流的最佳方法是采用 StringReader 类。

FileInputStream -- 把一个文件作为 InputStream ，实现对文件的读取操作

construct---

(A)FileInputStream(File name) 创建一个输入文件流，从指定的 File 对象读取数据。

(B)FileInputStream(FileDescriptor) 创建一个输入文件流，从指定的文件描述器读取数据。

(C)-FileInputStream(String  name) 创建一个输入文件流，从指定名称的文件读取数据。

method ---- 

实现了InputStream中的部分方法；

额外的两个方法：

getChannel()：这个方法返回一个FileChannel对象，这个主要用于JNIO中的通道的。

getFD()：这个方法返回一个FileDescriptor对象，这个在构造函数中使用过。

PipedInputStream ：实现了 pipe 的概念，主要在线程中使用 . 管道输入流是指一个通讯管道的接收端。

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

construct---

PipedInputStream() 创建一个管道输入流，它还未与一个管道输出流连接。

PipedInputStream(PipedOutputStream) 创建一个管道输入流 , 它已连接到一个管道输出流。

method---

实现了InputStream中的部分方法

额外的方法：

connection(PipedOutputStream):用来连接PipedOutputStream对象

 SequenceInputStream ：

把多个 InputStream 合并为一个 InputStream . “序列输入流”类允许应用程序把几个输入流连续地合并起来，

并且使它们像单个输入流一样出现。每个输入流依次被读取，直到到达该流的末尾。

然后“序列输入流”类关闭这个流并自动地切换到下一个输入流。

construct---

SequenceInputStream(Enumeration) 创建一个新的序列输入流，并用指定的输入流的枚举值初始化它。

SequenceInputStream(InputStream, InputStream) 创建一个新的序列输入流，初始化为首先 读输入流 s1, 然后读输入流 s2 。

method---

实现了InputStream中的部分方法。

public class TestSequence {    　　public static void main(String[] args)throws Exception{    　　//不管怎么样，先创建两个文件。从里面读取数据，（我的文件里面有内容！）    　　InputStream in1=new FileInputStream(new File("d:\\jack.txt"));    　　InputStream in2=new FileInputStream(new File("d:\\jack2.txt"));    　　//读取，数据后要生成的文件    　　OutputStream ou=new FileOutputStream(new File("d:\\jack3.txt"));    　　//创建SequenceInputStream类，    　　SequenceInputStream si=new SequenceInputStream(in1,in2);    　　//因为SequenceInputStream，是一个字节一个字节读，要判断一下是否读完了。    　　int c=0;    　　while((c=si.read())!=-1){    　　//这里也是一个字节一个字节写的。    　　ou.write(c);    　　}    　　//关闭所有的资源    　　si.close();    　　ou.close();    　　in2.close();    　　in1.close();    　　}    　　}   

ObjectInputStream：用于操作Object的stream，这个在stream主要用在对象传输的过程中，其中牵涉到了序列化的知识

construct---

ObjectInputStream():实例化一个ObjectInputStream对象

ObjectInputStream(InputStream):使用一个InputStream对象来实例化一个ObjectInputStream对象，其中InputStream就是对象的输入流

method---

实现了InputStream中的部分方法；

它自己有很多的额外的方法：

这里就只介绍一下readObject(Object)方法，就是将一个对象写入到stream中，但是这个object必须序列化

其他的还有像readInt,readFloat等这样基本类型的方法，因为基本类型对应的对象也都是Object.

 FilterInputStream：是一个过滤的InputStream

constructor---

FilterInputStream(InputStream):使用一个InputStream为参数实例化一个FilterInputStream,其实就是来修饰InputStream的

method---

实现了InputStream中的所有方法

他其实没有作用，他的众多子类是很有用的：

BufferedInputStream:使用缓冲区的stream

constructor---

BufferedInputStream(InputStream):使用InputStream为参数初始化实例

BufferedInputStream(InputStream,int):能够设置缓冲区大小的BufferedInputStream

method---

实现了FilterInputStream中的所有方法(其实也是实现了InputStream中的所有方法)

DataInputStream:数字格式化的stream

constructor---

DataInputStream(InputStream):使用InputStream参数来初始化实例

method---

实现了FilterInputStream中的部分方法

ByteArrayOutputStream ： 把信息存入内存中的一个缓冲区中 . 该类实现一个以字节数组形式写入数据的输出流。

当数据写入缓冲区时，它自动扩大。用 toByteArray() 和 toString() 能检索数据。

constructor---

(A)--- ByteArrayOutputStream() 创建一个新的字节数组输出流。

(B)--- ByteArrayOutputStream() 创建一个新的字节数组输出流。

(C)--- ByteArrayOutputStream(int) 创建一个新的字节数组输出流，并带有指定大小字节的缓冲区容量。

method---

实现了OutputStream的部分方法：

额外的方法：

toByteArray() 将字节流转化成一个字节数组，用于数据的检索

toString() 将字节流转化成一个String对象，默认采用系统的编码转化，同样可以用于数据的检索

toString(String) 根据指定字符编码将缓冲区内容转换为字符串，并将字节转换为字符。

writeTo(OutputStream) 用 out.write(buf, 0, count) 调用输出流的写方法将该字节数组输出流的全部内容写入指定的输出流参数。

 FileOutputStream: 文件输出流是向 File 或 FileDescriptor 输出数据的一个输出流。

constructor---

(A)FileOutputStream(File  name) 创建一个文件输出流，向指定的 File 对象输出数据。

(B)FileOutputStream(FileDescriptor) 创建一个文件输出流，向指定的文件描述器输出数据。

(C)FileOutputStream(String  name) 创建一个文件输出流，向指定名称的文件输出数据。

(D)FileOutputStream(String, boolean) 用指定系统的文件名，创建一个输出文件。

method---

实现了OutputStream中的部分方法。

额外的两个方法：

getChannel()：这个方法返回一个FileChannel对象，这个主要用于JNIO中的通道的。

getFD()：这个方法返回一个FileDescriptor对象，这个在构造函数中使用过。

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

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

constructor---

(A)PipedOutputStream() 创建一个管道输出流，它还未与一个管道输入流连接。

(B)PipedOutputStream(PipedInputStream) 创建一个管道输出流，它已连接到一个管道输入流。

method---

实现了OutputStream的部分方法

额外的方法：

connection(PipedInputStream):连接一个PipedInputStream方法

下面来看一下PipedInputStream和PipedOutputStream的例子：

[java] view plain copy

 

1. package com.io.demo;  
2.   
3. import java.io.BufferedInputStream;  
4. import java.io.BufferedReader;  
5. import java.io.ByteArrayInputStream;  
6. import java.io.IOException;  
7. import java.io.InputStreamReader;  
8. import java.io.PipedInputStream;  
9. import java.io.PipedOutputStream;  
10.   
11. public class IO {  
12.       
13.     public static void main(String[] args) throws Exception{  
14.           
15.         PipedOutputStream pos = new PipedOutputStream();  
16.         try {  
17.             PipedInputStream pis = new PipedInputStream(pos);  
18.             new Thread(new InputStreamRunnable(pis)).start();  
19.             new Thread(new OutputStreamRunnable(pos)).start();  
20.         } catch (IOException e) {  
21.             e.printStackTrace();  
22.         }  
23.     }  
24.       
25.     static class InputStreamRunnable implements Runnable{  
26.         private PipedInputStream pis = null;  
27.         public InputStreamRunnable(PipedInputStream pis){  
28.             this.pis = pis;  
29.         }  
30.         @Override  
31.         public void run() {  
32.             BufferedReader sr = new BufferedReader(new InputStreamReader(pis));  
33.             try {  
34.                 System.out.println("读取到的内容:"+sr.readLine());  
35.                 sr.close();  
36.             } catch (IOException e) {  
37.                 e.printStackTrace();  
38.             }  
39.         }  
40.           
41.     }  
42.       
43.     static class OutputStreamRunnable implements Runnable{  
44.         private PipedOutputStream pos = null;  
45.         public OutputStreamRunnable(PipedOutputStream pos){  
46.             this.pos = pos;  
47.         }  
48.         @Override  
49.         public void run(){  
50.             try {  
51.                 pos.write("Hello World!".getBytes());  
52.                 pos.close();  
53.             } catch (IOException e) {  
54.                 e.printStackTrace();  
55.             }  
56.         }  
57.     }  
58.   
59. }  

ObjectOutputStream:输出Object对象的stream

constructor---

ObjectOutputStream:实例化一个ObjectOutputStream对象

ObjectOutputStream(OutputStream):使用OutputStream对象来实例化一个ObjectOutputStream对象，将对象写入到OutputStream中

method---

实现了OutputStream中的部分方法

 FilterOutputStream:过滤的OutputStream

constructor---

FilterOutputStream(OutputStream):使用OutputStream参数实例化FilterOutputStream

method---

实现了OutputStream的所有方法

和FilterInputStream一样，他其实也没有什么用途，他的子类很有用的

BufferedOutputStream:带有缓冲区的stream

constructor---

BufferedOutputStream(OutputStream):使用OutputStream参数初始化BufferedOutputStream类

BufferedOutputStream(OutputStream,int)：在初始化实例的时候指定缓冲区的大小

method---

实现了FilterOutputStream中的部分方法

 DataOutputStream:具有格式化的OutputStream

constructor---

DataOutputStream(OutputStream):使用OutputStream参数来初始化DataOutputStream实例

method---

实现了FilterOutputStream中的部分方法

 PrintStream:直接输出到控制台中：我们最熟悉的就是System.out他就是一个PrintStream

constructor---

PrintStream(OutputStream):使用OutputStream参数来实例化PrintStream

method---

实现了FilterOutputStream中的部分方法

print()有多个重载的方法，8中基本类型和String类型，同时他还可以进行格式化输出。

 

 

 CharArrayReader ：与 ByteArrayInputStream 对应此类实现一个可用作字符输入流的字符缓冲区

constructor---

CharArrayReader(char[]) 用指定字符数组创建一个 CharArrayReader 。

CharArrayReader(char[], int, int) 用指定字符数组创建一个 CharArrayReader

method---

实现了部分Reader的方法

StringReader ： 与 StringBufferInputStream 对应其源为一个字符串的字符流。

FileReader ：与 FileInputStream 对应

PipedReader ：与 PipedInputStream 对应

InputStreamReader：将InputStream转化成Reader

 

CharArrayWriter： 与 ByteArrayOutputStream 对应

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

FileWriter： 与 FileOutputStream 对应

PipedWriter：与 PipedOutputStream 对应

OutputStreamWriter：将OutputStream转化成Writer

PrintReader：和PrintStream对应