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對象，這里不再給出源碼），使得我們的輸入更加簡單。

以上是輸出流的總結，總的來說，理解輸出流類的繼承關系和使用關系很重要，只有這樣才能知道如何使用輸出流。