IO包中的其他流对象

IO流中有四大体系：

字符流：Reader和 Writer

字节流：InputStream和OutputSream

基于这四大体系，io流中衍生出许多对象，常见的有FileReader，FileWriter，FileInputStream，FileOutputStream，BufferedInputStream等等。

除此之外，还有其他一些常见的对象，这些对象比较特殊，往往是针对某些特定功能的。我们在应用中凡是能和文件关联的流对象都是重要的流对象。

下面一一介绍：

1.打印流：PrintWriter和PrintStream

2.序列流：SequenceInputStream

3.操作对象的流：ObjectInputStream和ObjectOutputStream

4.管道流：PipedInputStream和PipedOutputStream

5.随机读写文件：RandomAccessFile

6.操作基本数据类型的流：DataInputStream和DataOutputStream

7.操作字节数组的流：ByteArrayInputStream和ByteArrayOutputStream

8.操作字符数组的流：CharArrayReader和CharArrayWriter

9.操作字符串的流：StringReader和StringWriter

一、PrintStream和PrintWriter

这两个流对象可以直接操作输入流和文件

PrintStream为其他输出流添加了功能，使它们能方便的打印各种数据值得表现形式，PrintStream永远不会抛出IOException，其具有的print()和println()方法可以对基本数据类型进行操作。可以保证数据的原样性将数据打印出去。

PrintStream的构造函数可以接收的参数类型有：

1.File对象：File

2.字符串路径：String

3.字节输出流：OutputStream

PrintWriter是一个常见的打印流，尤其在web开发中更常见。

PrintWriter构造函数可以接收的参数类型有：

1.File对象：File

2.字符串路径：String

3.字节输出流：OutputStream

4.字符输出流：Writer

示例：

public class PrintStreamDemo {
public static void main(String[] args) {
BufferedReader bufr = new BufferedReader(
new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out,true);
String line =null;
try {
while((line=bufr.readLine())!=null){
out.println(line.toUpperCase());
}
} catch (IOException e) {
e.printStackTrace();
}
out.close();
try {
bufr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

PrintWriter将数据保存到文件中：

PrintWriter out = new Printwriter(“a.txt”);

PrintWriter out = new PrintWriter(new FileWriter(“a.txt”),true);//true表示自动刷新

PrintWriter out = new PrintWriter(new BufferedWriter(

new FileWriter(“a.txt”),true));

二、SequenceInputStream

SequenceInputStream可以对多个流进行合并。

SequenceInputStream表示其他输入流的逻辑串联，它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，一次类推，知道到达包含的最后一个输入流的文件末尾为止。

SequenceInputStream可以用来将多个读取流合并成一个读取流。

示例：

public class SequenceDemo {
public static void main(String[] args) {
SequenceInputStream sis = null;
FileOutputStream fos = null;
try {
Vector<FileInputStream> v = new Vector<FileInputStream>();
v.add(new FileInputStream("E:\\1.txt"));
v.add(new FileInputStream("E:\\2.txt"));

Enumeration<FileInputStream> en = v.elements();
sis = new SequenceInputStream(en);
fos = new FileOutputStream("E:\\3.txt");
byte[] buf = new byte[1024];
int len =0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
sis.close();
} catch (IOException e) {
e.printStackTrace();
}

}
}
}

//切割文件
public static void splitFile() throws IOException{
FileInputStream fis = new FileInputStream("E:\\3.pdf");
FileOutputStream fos = null;
byte[] buf = new byte[1024*1024];
int len = 0;
int count = 1;
while((len=fis.read(buf))!=-1){
fos = new FileOutputStream("E:\\splitFiles\\"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}
//合并文件
public static void merge() throws IOException{
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for(int i=1; i<=32; i++){
al.add(new FileInputStream("E:\\splitFiles\\"+i+".part"));
}
final Iterator<FileInputStream> it = al.iterator();
Enumeration<FileInputStream> en = new Enumeration<FileInputStream>() {
@Override
public boolean hasMoreElements() {
return it.hasNext();
}
@Override
public FileInputStream nextElement() {
return it.next();
}
};
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("E:\\1.pdf");
byte[] buf = new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
fos.close();
sis.close();
}

三、ObjectInputStream和ObjectInputStream

ObjectOutputStream将java对象的基本数据类型和图形写入OutputStream，可以使用InputStream读取（重构）对象，通过在流中使用文件可实现对象的持久存储，如果流是网络套接字流，则可以在另一台主机上和另一个进程中重构对象。

示例：

public void writeObj() throws Exception{
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("a.txt"));
oos.writeObject(new Person("lisi",24));
oos.close();
}
public void readObj() throws Exception{
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("a.txt"));
Person p = (Person)ois.readObject();
ois.close();
}

上例中Person类需要实现序列化，即实现Serializable接口。实现序列化必须实现Serializable接口。

对象序列化也称对象持久化，即将堆内存中的对象封装到硬盘上。

Serializable接口没有方法，没有方法的接口称为标记接口。

通过使用关键字transient关键字将对象中的某个属性设置为不能被序列化。

例如：transient int age; //Person类中的age属性就不能被序列化。

四、PipedInputStream 和PipedOutputStream

管道流是涉及到多线程的io流。管道流因为管道的存在，输入和输出可以直接进行连接，通过结合线程使用。

通常数据由某个线程从PipedInputStream对象读取，并由其它线程将其写入到相应的PipedOutputStream,如果只使用单线程的话可能导致死锁。

示例：

public class Read implements Runnable{
private PipedInputStream in;
Read(PipedInputStream in){
this.in = in;
}
@Override
public void run() {
try {
byte[] buf = new byte[1024];
int len = in.read(buf);
String s = new String(buf,0,len);
System.out.println(s);
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public class Write implements Runnable{
private OutputStream out;
Write(OutputStream out){
this.out = out;
}
@Override
public void run() {
try {
out.write("aaaqqq".getBytes());
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public class PipedDemo {
public static void main(String[] args) {
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
try {
in.connect(out);
} catch (IOException e) {
e.printStackTrace();
}
Read r = new Read(in);
Write w = new Write(out);
new Thread(r).start();
new Thread(w).start();
}
}

五、RandomAccessFile

RandomAccessFile主要用于文件的随机读写，它继承自Object类，属于自成一派的工具类。具体用法详见随机读写文件RandomAccessFile。

六、DataOutputStream和DataInputStream

这两个流对象主要用于操作基本数据类型。

示例：

public void writeData() throws IOException{
DataOutputStream dos = new DataOutputStream(
new FileOutputStream("data.txt"));
dos.writeInt(123);
dos.writeBoolean(true);
dos.writeDouble(999.99);
dos.writeUTF("你好！");//utf-8修改版
dos.close();
}

public void ReadData() throws IOException{
DataInputStream dis = new DataInputStream(new
FileInputStream("data.txt"));
int num=dis.readInt();
boolean b = dis.readBoolean();
double d = dis.readDouble();
dis.close();
}

七、ByteArrayInputStream和ByteArrayOutputStream

这两个流对象主要用于操作字节数组。

ByteArrayInputStream包含一个内部缓冲区，该缓冲区包含从流中读取的字节。具备一个内部计数器，用于跟踪read方法要提供的下一个字节。此类中的方法在关闭此流后仍可以调用，不会产生IOException，即不需要关闭流对象，因为该流对象没有调用底层资源。

此外，ByteArrayInputStream在构造的时候，需要接收字节数组类型的数据源。

ByteArrayOutputStream实现了一个输出流，其中的数据被写入一个byte数组，缓冲区会随着数据的不断写入而自动增长。可以用toByteArray()和toString()方法来获取数据。此类中的方法在关闭此流后仍可被调用，不会产生IOException。

此外，ByteArrayOutputStream在构造的时候，不用定义数据目的，因为在该对象中已经内部封装了可变长度的字节数组，该数组就是数据目的地。

示例：用流的读写思想来操作数组。

public static void main(String[] args){
ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFG".getBytes());
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int by=0;
while((by=bis.read())!=-1){
bos.write(by);
}
System.out.println(bos.size());
System.out.println(bos.toString());
bos.write(new FileOutputStream("a.txt"));
}

八、CharArrayReader和CharArrayWriter

用于操作字符数组的流对象，用法同ByteArrayInputStream和ByteArrayOutputStream

九、StringReader和StringWriter

用于操作字符串的流对象，用法同ByteArrayInputStream和ByteArrayOutputStream