java IO之输出流——OutputStream

OutputStream抽象类是所有输出字节流的超类，输出流接收输出字节，并将这些字节发送到某个接收器。这个接收器可以是字节数组、文件、管道。该类的定义如下：

public abstract class OutputStream implements Closeable, Flushable {
    //将指定的字节写到这个输出流中
    public abstract void write(int b) throws IOException;
    //将指定字节数组中的内容写到输出流中
    public void write(byte b[]) throws IOException {
        write(b, 0, b.length);
    }
    public void write(byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if ((off < 0) || (off > b.length) || (len < 0) ||
                   ((off + len) > b.length) || ((off + len) < 0)) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return;
        }
        for (int i = 0 ; i < len ; i++) {
            write(b[off + i]);
        }
    }
    //清理输出流中的数据，迫使缓冲的字节写出去
    public void flush() throws IOException {
    }
    //关闭流
    public void close() throws IOException {
    }
}

输出字节流的类结构图如下，同样，这里只列举常用的几个类，还有很多未被列出。

 下面对不同的输出流进行简单的分析，会给出相应的类源码和示例。

1、ByteArrayOutputStream，字节数组输出流，此类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。 源代码如下：

import java.util.Arrays;
public class ByteArrayOutputStream extends OutputStream {
    //定义一个用于存储输出数据的缓冲数组
    protected byte buf[];
    protected int count;
    public ByteArrayOutputStream() {
        this(32);
    }
    public ByteArrayOutputStream(int size) {
        if (size < 0) {
            throw new IllegalArgumentException("Negative initial size: "+ size);
        }
        buf = new byte[size];
    }
    private void ensureCapacity(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - buf.length > 0)
            grow(minCapacity);
    }
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    //扩展缓冲数组大小
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = buf.length;
        int newCapacity = oldCapacity << 1;
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        buf = Arrays.copyOf(buf, newCapacity);
    }
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
    //将数字b写到缓冲数组中
    public synchronized void write(int b) {
        ensureCapacity(count + 1);
        buf[count] = (byte) b;
        count += 1;
    }
    public synchronized void write(byte b[], int off, int len) {
        if ((off < 0) || (off > b.length) || (len < 0) ||
            ((off + len) - b.length > 0)) {
            throw new IndexOutOfBoundsException();
        }
        ensureCapacity(count + len);
        System.arraycopy(b, off, buf, count, len);
        count += len;
    }
    //将此 byte 数组输出流的全部内容写入到指定的输出流参数中，
    //这与使用 out.write(buf, 0, count) 调用该输出流的 write 方法效果一样。    
    public synchronized void writeTo(OutputStream out) throws IOException {
        out.write(buf, 0, count);
    }
    public synchronized void reset() {
        count = 0;
    }
    //将输出的内容以字符数组的形式返给用户
    public synchronized byte toByteArray()[] {
        return Arrays.copyOf(buf, count);
    }
    public synchronized int size() {
        return count;
    }
    //将输出的内容以字符串的形式返给用户
    public synchronized String toString() {
        return new String(buf, 0, count);
    }
    //将输出的内容以以指定字符编码的字符串形式返给用户
    public synchronized String toString(String charsetName)
        throws UnsupportedEncodingException
    {
        return new String(buf, 0, count, charsetName);
    }
    @Deprecated
    public synchronized String toString(int hibyte) {
        return new String(buf, hibyte, 0, count);
    }
    public void close() throws IOException {
    }
}

从源码可以看出，涉及到数据操作的方法都加了synchronized关键字，所以该类是安全同步的类。使用方法如下：

static void byteArrayOutputTest(){
        ByteArrayOutputStream out=new ByteArrayOutputStream(8);
        try{
            while(out.size()!=8){
                out.write(System.in.read());
            }
            for(byte by:out.toByteArray()){
                System.out.print((char)by+" ");
            }
            System.out.println();
        }catch(Exception e){
            e.printStackTrace();
        }        
    }

我们创建了一个字节数组输出流，它的缓冲容量大小为8，然后我们从控制台进行输入，输入的时候可以不加空格，如果添加空格，空格也计数在内，可以输入多个字符，但最后输出的字符数只有8个，因为我们已经指定了缓冲容量的大小，当用toByteArray()方法取出数据时，它返回的字符数组长度为8.

2、FileOutputStream，文件输出流，它是将数据输出到文件中，注意这里操作对象——文件的可用与否与平台有关，某些平台一次只允许一个 FileOutputStream（或其他文件写入对象）打开文件进行写入。在这种情况下，如果所涉及的文件已经打开，则此类中的构造方法将失败。


import java.nio.channels.FileChannel;
import sun.nio.ch.FileChannelImpl;
public class FileOutputStream extends OutputStream
{
    private final FileDescriptor fd;
    private final boolean append;
    private FileChannel channel;
    private final String path;
    private final Object closeLock = new Object();
    private volatile boolean closed = false;
    //创建文件输出流，如果文件不存在，则自动创建文件
    public FileOutputStream(String name) throws FileNotFoundException {
        this(name != null ? new File(name) : null, false);
    }
    //创建文件输出流，如果文件不存在，则自动创建文件
    //同时指定文件是否具有追加内容的功能，如果有，则新添内容放到文件后面，而不覆盖源文件内容
    public FileOutputStream(String name, boolean append)
        throws FileNotFoundException
    {
        this(name != null ? new File(name) : null, append);
    }
    public FileOutputStream(File file) throws FileNotFoundException {
        this(file, false);
    }
    //创建文件输出流，并指定可以在文件最后追加内容，如果没有指定，则将原来内容覆盖
    public FileOutputStream(File file, boolean append)
        throws FileNotFoundException
    {
        String name = (file != null ? file.getPath() : null);
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkWrite(name);
        }
        if (name == null) {
            throw new NullPointerException();
        }
        if (file.isInvalid()) {
            throw new FileNotFoundException("Invalid file path");
        }
        this.fd = new FileDescriptor();
        fd.attach(this);
        this.append = append;
        this.path = name;
        open(name, append);
    }
    public FileOutputStream(FileDescriptor fdObj) {
        SecurityManager security = System.getSecurityManager();
        if (fdObj == null) {
            throw new NullPointerException();
        }
        if (security != null) {
            security.checkWrite(fdObj);
        }
        this.fd = fdObj;
        this.append = false;
        this.path = null;
        fd.attach(this);
    }
    private native void open0(String name, boolean append)
        throws FileNotFoundException;
    private void open(String name, boolean append)
        throws FileNotFoundException {
        open0(name, append);
    }
    //调用本地方法，将内容写入指定文件
    private native void write(int b, boolean append) throws IOException;
    public void write(int b) throws IOException {
        write(b, append);
    }
    private native void writeBytes(byte b[], int off, int len, boolean append)
        throws IOException;
    //将字符数组内容写进文件
    public void write(byte b[]) throws IOException {
        writeBytes(b, 0, b.length, append);
    }
    public void write(byte b[], int off, int len) throws IOException {
        writeBytes(b, off, len, append);
    }
    //关闭文件流
    public void close() throws IOException {
        synchronized (closeLock) {
            if (closed) {
                return;
            }
            closed = true;
        }
        if (channel != null) {
            channel.close();
        }

        fd.closeAll(new Closeable() {
            public void close() throws IOException {
               close0();
           }
        });
    }
     public final FileDescriptor getFD()  throws IOException {
        if (fd != null) {
            return fd;
        }
        throw new IOException();
     }
    public FileChannel getChannel() {
        synchronized (this) {
            if (channel == null) {
                channel = FileChannelImpl.open(fd, path, false, true, append, this);
            }
            return channel;
        }
    }
    //清除文件流缓冲内容，并关闭文件流
    protected void finalize() throws IOException {
        if (fd != null) {
            if (fd == FileDescriptor.out || fd == FileDescriptor.err) {
                flush();
            } else {
                close();
            }
        }
    }
    private native void close0() throws IOException;
    private static native void initIDs();
    static {
        initIDs();
    }
}

文件输出流操作不是线程安全的，如果用于多线程访问，注意使用同步。以下是文件输出流操作的例子：

//文件输出流测试
    static void fileOutputTest(){
        FileOutputStream fout=null;
        FileInputStream fin=null;
        try{
            //从my.java文件中读取内容
            fin=new FileInputStream("my.java");
            fout=new FileOutputStream("out.txt");
            byte[] buff=new byte[1024];
            while(fin.read(buff)>0){
                //FileInputStream将从my.java文件中读取到的内容写到buff数组中
                //然后FileOutputStream将buff数组中的内容写到流中
                fout.write(buff);
            }//将流中缓冲的内容输出到文件中
            fout.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(fout!=null)
                    fout.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }

为了减少操作，这里使用了文件输入流对象，我们从my.java文件中读取内容，然后将读取到的内容写到out.txt文件中，从my.java文件中读取内容要用输入流，向文件中写内容要用输出流，这里两种流都做了使用。

3、FilterOutputStream,该类是提供输出流的装饰器类的接口，继承该类的子类相当于一个装饰器，能够为OutputStream类型的对象操作提供额外的功能，这里以BufferedOutputStream为例，该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。 比如，我们需要向一个文件中输入内容，这时候我们可以先将内容存储到缓冲数组中，并不是真的向该文件写内容，当调用flush()方法或关闭流时，内容才真正写到文件中。该类的源码如下：

public class BufferedOutputStream extends FilterOutputStream {
    //内部存储数据的缓冲数组
    protected byte buf[];
     //缓冲中的有效字节数目
    protected int count;
    //创建一个缓冲输出流，将时数据写到特定的底层输出流中
    public BufferedOutputStream(OutputStream out) {
        this(out, 8192);
    }
    //创建一个缓冲输出流，将时数据写到具有特定大小容量的特定的底层输出流中
    public BufferedOutputStream(OutputStream out, int size) {
        super(out);
        if (size <= 0) {
            throw new IllegalArgumentException("Buffer size <= 0");
        }
        buf = new byte[size];
    }
    //将缓冲中的数据清理出去，输出到目的地
    private void flushBuffer() throws IOException {
        if (count > 0) {
            out.write(buf, 0, count);
            count = 0;
        }
    }
    //将指定的字节写到缓冲输出流中
    public synchronized void write(int b) throws IOException {
        if (count >= buf.length) {
            flushBuffer();
        }
        buf[count++] = (byte)b;
    }
    //从指定位置off开始，将b数组内的len个字节写到缓冲输出流中
    //一般来说，此方法将给定数组的字节存入此流的缓冲区中，根据需要将该缓冲区刷新，并转到底层输出流。
    //但是，如果请求的长度至少与此流的缓冲区大小相同，则此方法将刷新该缓冲区并将各个字节直接写入底层输出流。因此多余的 BufferedOutputStream 将不必复制数据。 
    public synchronized void write(byte b[], int off, int len) throws IOException {
        if (len >= buf.length) {
            flushBuffer();
            out.write(b, off, len);
            return;
        }
        if (len > buf.length - count) {
            flushBuffer();
        }
        System.arraycopy(b, off, buf, count, len);
        count += len;
    }
    //刷新此缓冲的输出流。这迫使所有缓冲的输出字节被写出到底层输出流中。 
    public synchronized void flush() throws IOException {
        flushBuffer();
        out.flush();
    }
}

从源码来看，可以得知，该类也是线程同步的，所以在多线程环境下能够保证访问的正确性。下面给出该类的一个示例：

//缓冲输出流测试
    static void bufferedOutputTest(){
        BufferedOutputStream bof=null;
        BufferedInputStream bin=null;
        FileOutputStream fout=null;
        FileInputStream fin=null;
        byte[] buff=new byte[1024];
        try{
            fin=new FileInputStream("my.java");
            bin=new BufferedInputStream(fin);
            fout=new FileOutputStream("out.txt");
            bof=new BufferedOutputStream(fout);
            while(fin.read(buff)>0){
                bof.write(buff,0,buff.length);
            }
            //如果将下面这一行注释掉，而且有没有将bof关掉，则out.txt文件中不会有内容出现
            //因为内容还在缓冲中，还未并没有输出到文本上
            bof.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(bof!=null)
                    bof.close();
                if(fout!=null)
                    fout.close();
                if(fin!=null)
                    fin.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }

该示例同样用了输入流，为了操作方便，我们直接向一个文件中读取数据，所以要用输入流，然后将读取到的数据输出到另一个文件中，如果out.txt文件不存在，则会自动创建该文件，在输出数据时，可以利用flush函数及时将缓冲数组中的内容输出到文件中。

4、DataOutputStream，数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。下面是该类源码：

//DataOutputStream允许应用程序将基本的java数据类型写入到一个输出流中，
 //同时应用程序还可以用一个DataInputStream将数据读回。
public class DataOutputStream extends FilterOutputStream implements DataOutput {
    //记录当前写到数据输入流中的字节数
    protected int written;
    //bytearr根据请求，由writeUTF进行初始化
    private byte[] bytearr = null;
    public DataOutputStream(OutputStream out) {
        super(out);
    }
    private void incCount(int value) {
        int temp = written + value;
        if (temp < 0) {//输入字节数操作能够表示的最大数
            temp = Integer.MAX_VALUE;
        }
        written = temp;
    }
    //将指定的字节b写到底层的输出流
    public synchronized void write(int b) throws IOException {
        out.write(b);
        incCount(1);
    }
    public synchronized void write(byte b[], int off, int len)
        throws IOException
    {
        out.write(b, off, len);
        incCount(len);
    }
    //清理输出流，迫使所有缓冲的输出字节被写出到流中。 
    public void flush() throws IOException {
        out.flush();
    }
    //将值为ture的boolean类型的数据以1的形式记录
    public final void writeBoolean(boolean v) throws IOException {
        out.write(v ? 1 : 0);
        incCount(1);
    }
    //将一个 byte 值以 1-byte 值形式写出到基础输出流中
    public final void writeByte(int v) throws IOException {
        out.write(v);
        incCount(1);
    }
    public final void writeShort(int v) throws IOException {
        out.write((v >>> 8) & 0xFF);
        out.write((v >>> 0) & 0xFF);
        incCount(2);
    }
    public final void writeChar(int v) throws IOException {
        out.write((v >>> 8) & 0xFF);
        out.write((v >>> 0) & 0xFF);
        incCount(2);
    }
    public final void writeInt(int v) throws IOException {
        out.write((v >>> 24) & 0xFF);
        out.write((v >>> 16) & 0xFF);
        out.write((v >>>  8) & 0xFF);
        out.write((v >>>  0) & 0xFF);
        incCount(4);
    }
    private byte writeBuffer[] = new byte[8];
    public final void writeLong(long v) throws IOException {
        writeBuffer[0] = (byte)(v >>> 56);
        writeBuffer[1] = (byte)(v >>> 48);
        writeBuffer[2] = (byte)(v >>> 40);
        writeBuffer[3] = (byte)(v >>> 32);
        writeBuffer[4] = (byte)(v >>> 24);
        writeBuffer[5] = (byte)(v >>> 16);
        writeBuffer[6] = (byte)(v >>>  8);
        writeBuffer[7] = (byte)(v >>>  0);
        out.write(writeBuffer, 0, 8);
        incCount(8);
    }
    public final void writeFloat(float v) throws IOException {
        writeInt(Float.floatToIntBits(v));
    }
    public final void writeDouble(double v) throws IOException {
        writeLong(Double.doubleToLongBits(v));
    }
    public final void writeBytes(String s) throws IOException {
        int len = s.length();
        for (int i = 0 ; i < len ; i++) {
            out.write((byte)s.charAt(i));
        }
        incCount(len);
    }
    public final void writeChars(String s) throws IOException {
        int len = s.length();
        for (int i = 0 ; i < len ; i++) {
            int v = s.charAt(i);
            out.write((v >>> 8) & 0xFF);
            out.write((v >>> 0) & 0xFF);
        }
        incCount(len * 2);
    }
    public final void writeUTF(String str) throws IOException {
        writeUTF(str, this);
    }
    public final int size() {
        return written;
    }
}

从源码可以看出，该类也是线程安全的。具体的使用方法通过一个示例来了解，如下：

static void dataOutputTest(){
        DataOutputStream dout=null;
        FileOutputStream fout=null;
        DataInputStream din=null;
        FileInputStream fin=null;
        int[] arr={1,2,3,4,5};
        try{
            fout=new FileOutputStream("out.txt");
            dout=new DataOutputStream(fout);
            for(int val:arr){
                //将数据读入到文件中
                dout.writeInt(val);
            }
            //从文件中读出数据
            fin=new FileInputStream("out.txt");
            din=new DataInputStream(fin);
            while(din.available()>0){
                System.out.print(din.readInt()+" ");
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(fin!=null)
                    fin.close();
                if(fout!=null)
                    fout.close();
                if(din!=null)
                    din.close();
                if(dout!=null)
                    dout.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }

我们可以向文件中写入基本的java数据，也可以相应地读出这些数据，读出数据同样用到了输入流。

5、PrintStream,打印流，同样也是一个装饰器，可以为其他输出流添加功能，PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。我们用的最多的输出就是System.out.println()方法，直接将内容输出到控制台上，其中，System是一个包含几个静态变量和静态方法的类，它不能够被实例化，其中一个静态变量out就是PrintStream类型的对象，使用System.out.println默认将输出送到控制台上，我们也可以将内容输出到一个文件中，如下例子：

static void printStreamTest(){
        PrintStream pri=null;
        try{
            pri=new PrintStream("out.txt");
            pri.print("hello,world");
            pri.println();
            pri.println(12);
            pri.close();
        }catch(Exception e){
            e.printStackTrace();
        }
    }

我们可以利用println方法，将内容输出到一个文件中，其实这就是装饰器的功能，它增强了FileOutputStream的功能（注意，我们这里是将内容输出到一个文件中，所以PrintStream类内部调用的是FileOutputStream对象，这里不再给出源码），使得我们的输入更加简单。

以上是输出流的总结，总的来说，理解输出流类的继承关系和使用关系很重要，只有这样才能知道如何使用输出流。