黑马程序员—IO包中的其他流对象

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
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();
            }

        }
    }
}

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

public void writeObj() throw Exception{
    ObjectOutputStream oos = new ObjectOutputStream(
        new FileOutputStream("a.txt"));
    oos.writeObject(new Person("lisi",24));
oos.close();
}

四、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() throw 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() throw 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