thinking in java (二十五) ----- IO之PrintStream

阿新 • • 發佈：2018-11-16

PrintStream介紹

PrintStream是列印輸出流，繼承自FilterOutputStream,PrintStream用來裝飾其他的流，為其他流新增列印功能，使其能夠方便列印各種資料表現形式。

與其他流不同，PrintStream永遠不會丟擲IOException，他產生的IOException會被自身的函式所捕獲並設定錯誤標記，

另外，PrintStream提供了自動flush（）和字符集設定功能，所謂自動flush，就是PrintStream寫入的資料會立刻呼叫flush函式。注意：print（），println（）都是將其中引數轉換為字串後，再寫入到輸出流

方法列表

/* 
 * 建構函式
 */
// 將“輸出流out”作為PrintStream的輸出流，不會自動flush，並且採用預設字符集
// 所謂“自動flush”，就是每次執行print(), println(), write()函式，都會呼叫flush()函式；
// 而“不自動flush”，則需要我們手動呼叫flush()介面。
PrintStream(OutputStream out)
// 將“輸出流out”作為PrintStream的輸出流，自動flush，並且採用預設字符集。
PrintStream(OutputStream out, boolean autoFlush)
// 將“輸出流out”作為PrintStream的輸出流，自動flush，採用charsetName字符集。
PrintStream(OutputStream out, boolean autoFlush, String charsetName)
// 建立file對應的FileOutputStream，然後將該FileOutputStream作為PrintStream的輸出流，不自動flush，採用預設字符集。
PrintStream(File file)
// 建立file對應的FileOutputStream，然後將該FileOutputStream作為PrintStream的輸出流，不自動flush，採用charsetName字符集。
PrintStream(File file, String charsetName)
// 建立fileName對應的FileOutputStream，然後將該FileOutputStream作為PrintStream的輸出流，不自動flush，採用預設字符集。
PrintStream(String fileName)
// 建立fileName對應的FileOutputStream，然後將該FileOutputStream作為PrintStream的輸出流，不自動flush，採用charsetName字符集。
PrintStream(String fileName, String charsetName)

// 將“字元c”追加到“PrintStream輸出流中”
PrintStream     append(char c)
// 將“字元序列從start(包括)到end(不包括)的全部字元”追加到“PrintStream輸出流中”
PrintStream     append(CharSequence charSequence, int start, int end)
// 將“字元序列的全部字元”追加到“PrintStream輸出流中”
PrintStream     append(CharSequence charSequence)
// flush“PrintStream輸出流緩衝中的資料”，並檢查錯誤
boolean     checkError()
// 關閉“PrintStream輸出流”
synchronized void     close()
// flush“PrintStream輸出流緩衝中的資料”。
// 例如，PrintStream裝飾的是FileOutputStream，則呼叫flush時會將資料寫入到檔案中
synchronized void     flush()
// 根據“Locale值(區域屬性)”來格式化資料
PrintStream     format(Locale l, String format, Object... args)
// 根據“預設的Locale值(區域屬性)”來格式化資料
PrintStream     format(String format, Object... args)
// 將“float資料f對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
void     print(float f)
// 將“double資料d對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
void     print(double d)
// 將“字串資料str”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
synchronized void     print(String str)
// 將“物件o對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
void     print(Object o)
// 將“字元c對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
void     print(char c)
// 將“字元陣列chars對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
void     print(char[] chars)
// 將“long型資料l對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
void     print(long l)
// 將“int資料i對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
void     print(int i)
// 將“boolean資料b對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
void     print(boolean b)
// 將“資料args”根據“Locale值(區域屬性)”按照format格式化，並寫入到“PrintStream輸出流”中
PrintStream     printf(Locale l, String format, Object... args)
// 將“資料args”根據“預設Locale值(區域屬性)”按照format格式化，並寫入到“PrintStream輸出流”中
PrintStream     printf(String format, Object... args)
// 將“換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
void     println()
// 將“float資料對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
void     println(float f)
// 將“int資料對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
void     println(int i)
// 將“long資料對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
void     println(long l)
// 將“物件o對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
void     println(Object o)
// 將“字元陣列chars對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
void     println(char[] chars)
// 將“字串str+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
synchronized void     println(String str)
// 將“字元c對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
void     println(char c)
// 將“double資料對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
void     println(double d)
// 將“boolean資料對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
void     println(boolean b)
// 將資料oneByte寫入到“PrintStream輸出流”中。oneByte雖然是int型別，但實際只會寫入一個位元組
synchronized void     write(int oneByte)
// 將“buffer中從offset開始的length個位元組”寫入到“PrintStream輸出流”中。
void     write(byte[] buffer, int offset, int length)

原始碼分析

package java.io;

import java.util.Formatter;
import java.util.Locale;
import java.nio.charset.Charset;
import java.nio.charset.IllegalCharsetNameException;
import java.nio.charset.UnsupportedCharsetException;

public class PrintStream extends FilterOutputStream
    implements Appendable, Closeable
{

    // 自動flush
    // 所謂“自動flush”，就是每次執行print(), println(), write()函式，都會呼叫flush()函式；
    // 而“不自動flush”，則需要我們手動呼叫flush()介面。
    private final boolean autoFlush;
    // PrintStream是否右產生異常。當PrintStream有異常產生時，會被本身捕獲，並設定trouble為true
    private boolean trouble = false;
    // 用於格式化的物件
    private Formatter formatter;

    // BufferedWriter物件，用於實現“PrintStream支援字符集”。
    // 因為PrintStream是OutputStream的子類，所以它本身不支援字串；
    // 但是BufferedWriter支援字符集，因此可以通過OutputStreamWriter建立PrintStream對應的BufferedWriter物件，從而支援字符集。
    private BufferedWriter textOut;
    private OutputStreamWriter charOut;

    private static <T> T requireNonNull(T obj, String message) {
        if (obj == null)
            throw new NullPointerException(message);
        return obj;
    }

    // 返回csn對應的字符集物件
    private static Charset toCharset(String csn)
        throws UnsupportedEncodingException
    {
        requireNonNull(csn, "charsetName");
        try {
            return Charset.forName(csn);
        } catch (IllegalCharsetNameException|UnsupportedCharsetException unused) {
            // UnsupportedEncodingException should be thrown
            throw new UnsupportedEncodingException(csn);
        }
    }

    // 將“輸出流out”作為PrintStream的輸出流，autoFlush的flush模式，並且採用預設字符集。
    private PrintStream(boolean autoFlush, OutputStream out) {
        super(out);
        this.autoFlush = autoFlush;
        this.charOut = new OutputStreamWriter(this);
        this.textOut = new BufferedWriter(charOut);
    }

    // 將“輸出流out”作為PrintStream的輸出流，自動flush，採用charsetName字符集。
    private PrintStream(boolean autoFlush, OutputStream out, Charset charset) {
        super(out);
        this.autoFlush = autoFlush;
        this.charOut = new OutputStreamWriter(this, charset);
        this.textOut = new BufferedWriter(charOut);
    }

    // 將“輸出流out”作為PrintStream的輸出流，自動flush，採用charsetName字符集。
    private PrintStream(boolean autoFlush, Charset charset, OutputStream out)
        throws UnsupportedEncodingException
    {
        this(autoFlush, out, charset);
    }

    // 將“輸出流out”作為PrintStream的輸出流，不會自動flush，並且採用預設字符集
    public PrintStream(OutputStream out) {
        this(out, false);
    }

    // 將“輸出流out”作為PrintStream的輸出流，自動flush，並且採用預設字符集。
    public PrintStream(OutputStream out, boolean autoFlush) {
        this(autoFlush, requireNonNull(out, "Null output stream"));
    }

    // 將“輸出流out”作為PrintStream的輸出流，自動flush，採用charsetName字符集。
    public PrintStream(OutputStream out, boolean autoFlush, String encoding)
        throws UnsupportedEncodingException
    {
        this(autoFlush,
             requireNonNull(out, "Null output stream"),
             toCharset(encoding));
    }

    // 建立fileName對應的FileOutputStream，然後將該FileOutputStream作為PrintStream的輸出流，不自動flush，採用預設字符集。
    public PrintStream(String fileName) throws FileNotFoundException {
        this(false, new FileOutputStream(fileName));
    }

    // 建立fileName對應的FileOutputStream，然後將該FileOutputStream作為PrintStream的輸出流，不自動flush，採用charsetName字符集。
    public PrintStream(String fileName, String csn)
        throws FileNotFoundException, UnsupportedEncodingException
    {
        // ensure charset is checked before the file is opened
        this(false, toCharset(csn), new FileOutputStream(fileName));
    }

    // 建立file對應的FileOutputStream，然後將該FileOutputStream作為PrintStream的輸出流，不自動flush，採用預設字符集。
    public PrintStream(File file) throws FileNotFoundException {
        this(false, new FileOutputStream(file));
    }

    // 建立file對應的FileOutputStream，然後將該FileOutputStream作為PrintStream的輸出流，不自動flush，採用csn字符集。
    public PrintStream(File file, String csn)
        throws FileNotFoundException, UnsupportedEncodingException
    {
        // ensure charset is checked before the file is opened
        this(false, toCharset(csn), new FileOutputStream(file));
    }

    private void ensureOpen() throws IOException {
        if (out == null)
            throw new IOException("Stream closed");
    }

    // flush“PrintStream輸出流緩衝中的資料”。
    // 例如，PrintStream裝飾的是FileOutputStream，則呼叫flush時會將資料寫入到檔案中
    public void flush() {
        synchronized (this) {
            try {
                ensureOpen();
                out.flush();
            }
            catch (IOException x) {
                trouble = true;
            }
        }
    }

    private boolean closing = false; /* To avoid recursive closing */

    // 關閉PrintStream
    public void close() {
        synchronized (this) {
            if (! closing) {
                closing = true;
                try {
                    textOut.close();
                    out.close();
                }
                catch (IOException x) {
                    trouble = true;
                }
                textOut = null;
                charOut = null;
                out = null;
            }
        }
    }

    // flush“PrintStream輸出流緩衝中的資料”，並檢查錯誤
    public boolean checkError() {
        if (out != null)
            flush();
        if (out instanceof java.io.PrintStream) {
            PrintStream ps = (PrintStream) out;
            return ps.checkError();
        }
        return trouble;
    }

    protected void setError() {
        trouble = true;
    }

    protected void clearError() {
        trouble = false;
    }

    // 將資料b寫入到“PrintStream輸出流”中。b雖然是int型別，但實際只會寫入一個位元組
    public void write(int b) {
        try {
            synchronized (this) {
                ensureOpen();
                out.write(b);
                if ((b == '\n') && autoFlush)
                    out.flush();
            }
        }
        catch (InterruptedIOException x) {
            Thread.currentThread().interrupt();
        }
        catch (IOException x) {
            trouble = true;
        }
    }

    // 將“buf中從off開始的length個位元組”寫入到“PrintStream輸出流”中。
    public void write(byte buf[], int off, int len) {
        try {
            synchronized (this) {
                ensureOpen();
                out.write(buf, off, len);
                if (autoFlush)
                    out.flush();
            }
        }
        catch (InterruptedIOException x) {
            Thread.currentThread().interrupt();
        }
        catch (IOException x) {
            trouble = true;
        }
    }

    // 將“buf中的全部資料”寫入到“PrintStream輸出流”中。
    private void write(char buf[]) {
        try {
            synchronized (this) {
                ensureOpen();
                textOut.write(buf);
                textOut.flushBuffer();
                charOut.flushBuffer();
                if (autoFlush) {
                    for (int i = 0; i < buf.length; i++)
                        if (buf[i] == '\n')
                            out.flush();
                }
            }
        }
        catch (InterruptedIOException x) {
            Thread.currentThread().interrupt();
        }
        catch (IOException x) {
            trouble = true;
        }
    }

    // 將“字串s”寫入到“PrintStream輸出流”中。
    private void write(String s) {
        try {
            synchronized (this) {
                ensureOpen();
                textOut.write(s);
                textOut.flushBuffer();
                charOut.flushBuffer();
                if (autoFlush && (s.indexOf('\n') >= 0))
                    out.flush();
            }
        }
        catch (InterruptedIOException x) {
            Thread.currentThread().interrupt();
        }
        catch (IOException x) {
            trouble = true;
        }
    }

    // 將“換行符”寫入到“PrintStream輸出流”中。
    private void newLine() {
        try {
            synchronized (this) {
                ensureOpen();
                textOut.newLine();
                textOut.flushBuffer();
                charOut.flushBuffer();
                if (autoFlush)
                    out.flush();
            }
        }
        catch (InterruptedIOException x) {
            Thread.currentThread().interrupt();
        }
        catch (IOException x) {
            trouble = true;
        }
    }

    // 將“boolean資料對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
    public void print(boolean b) {
        write(b ? "true" : "false");
    }

    // 將“字元c對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
    public void print(char c) {
        write(String.valueOf(c));
    }

    // 將“int資料i對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
    public void print(int i) {
        write(String.valueOf(i));
    }

    // 將“long型資料l對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
    public void print(long l) {
        write(String.valueOf(l));
    }

    // 將“float資料f對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
    public void print(float f) {
        write(String.valueOf(f));
    }

    // 將“double資料d對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
    public void print(double d) {
        write(String.valueOf(d));
    }

    // 將“字元陣列s”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
    public void print(char s[]) {
        write(s);
    }

    // 將“字串資料s”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
    public void print(String s) {
        if (s == null) {
            s = "null";
        }
        write(s);
    }

    // 將“物件obj對應的字串”寫入到“PrintStream輸出流”中，print實際呼叫的是write函式
    public void print(Object obj) {
        write(String.valueOf(obj));
    }


    // 將“換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
    public void println() {
        newLine();
    }

    // 將“boolean資料對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
    public void println(boolean x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

    // 將“字元x對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
    public void println(char x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

    // 將“int資料對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
    public void println(int x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

    // 將“long資料對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
    public void println(long x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

    // 將“float資料對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
    public void println(float x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

    // 將“double資料對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
    public void println(double x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

    // 將“字元陣列x+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
    public void println(char x[]) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

    // 將“字串x+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
    public void println(String x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

    // 將“物件o對應的字串+換行符”寫入到“PrintStream輸出流”中，println實際呼叫的是write函式
    public void println(Object x) {
        String s = String.valueOf(x);
        synchronized (this) {
            print(s);
            newLine();
        }
    }

    // 將“資料args”根據“預設Locale值(區域屬性)”按照format格式化，並寫入到“PrintStream輸出流”中
    public PrintStream printf(String format, Object ... args) {
        return format(format, args);
    }

    // 將“資料args”根據“Locale值(區域屬性)”按照format格式化，並寫入到“PrintStream輸出流”中
    public PrintStream printf(Locale l, String format, Object ... args) {
        return format(l, format, args);
    }

    // 根據“預設的Locale值(區域屬性)”來格式化資料
    public PrintStream format(String format, Object ... args) {
        try {
            synchronized (this) {
                ensureOpen();
                if ((formatter == null)
                    || (formatter.locale() != Locale.getDefault()))
                    formatter = new Formatter((Appendable) this);
                formatter.format(Locale.getDefault(), format, args);
            }
        } catch (InterruptedIOException x) {
            Thread.currentThread().interrupt();
        } catch (IOException x) {
            trouble = true;
        }
        return this;
    }

    // 根據“Locale值(區域屬性)”來格式化資料
    public PrintStream format(Locale l, String format, Object ... args) {
        try {
            synchronized (this) {
                ensureOpen();
                if ((formatter == null)
                    || (formatter.locale() != l))
                    formatter = new Formatter(this, l);
                formatter.format(l, format, args);
            }
        } catch (InterruptedIOException x) {
            Thread.currentThread().interrupt();
        } catch (IOException x) {
            trouble = true;
        }
        return this;
    }

    // 將“字元序列的全部字元”追加到“PrintStream輸出流中”
    public PrintStream append(CharSequence csq) {
        if (csq == null)
            print("null");
        else
            print(csq.toString());
        return this;
    }

    // 將“字元序列從start(包括)到end(不包括)的全部字元”追加到“PrintStream輸出流中”
    public PrintStream append(CharSequence csq, int start, int end) {
        CharSequence cs = (csq == null ? "null" : csq);
        write(cs.subSequence(start, end).toString());
        return this;
    }

    // 將“字元c”追加到“PrintStream輸出流中”
    public PrintStream append(char c) {
        print(c);
        return this;
    }
}

說明：
PrintStream的原始碼比較簡單，請上文的註釋進行閱讀。若有不明白的地方，建議先看看後面的PrintStream使用示例；待搞清它的作用和用法之後，再來閱讀原始碼。

PrintStream和DataOutputStream異同點

1，PrintStream和DataOutputStream都可以將資料格式化輸出，但是他們再輸出“字串”時候的編碼不同

PrintStream輸出時採用的是使用者指定的編碼，沒有指定就採用系統預設的編碼，而DataOutputStream使用的是UTF-8

2，他們寫入數據時處理異常機制不同

DataOutputStream通過write（）方法寫入資料，若產生IOException，會丟擲

PrintStream通過write（）寫入資料如果產生了IOException，則會在write（）中進行捕獲，並設定trouble標記為true，使用者可以通過checkError()返回trouble值，從未檢查輸出流是否有錯誤

3，建構函式不同

DataOutputStream的建構函式只有一個：DataOutputStream(OutputStream out)。即它只支援以輸出流out作為“DataOutputStream的輸出流”。
而PrintStream的建構函式有許多：和DataOutputStream一樣，支援以輸出流out作為“PrintStream輸出流”的建構函式；還支援以“File物件”或者“String型別的檔名物件”的建構函式。而且，在PrintStream的建構函式中，能“指定字符集”和“是否支援自動flush()操作”。

4，目的不同

DataOutputStream的作用是裝飾其它的輸出流，它和DataInputStream配合使用：允許應用程式以與機器無關的方式從底層輸入流中讀寫java資料型別。
而PrintStream的作用雖然也是裝飾其他輸出流，但是它的目的不是以與機器無關的方式從底層讀寫java資料型別；而是為其它輸出流提供列印各種資料值表示形式，使其它輸出流能方便的通過print(), println()或printf()等輸出各種格式的資料。

示例程式碼

package io;
import java.io.PrintStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * PrintStream 的示例程式
 *
 * @author skywang
 */
public class PrintStreamTest {

    public static void main(String[] args) {

        // 下面3個函式的作用都是一樣：都是將字母“abcde”寫入到檔案“file.txt”中。
        // 任選一個執行即可！
        testPrintStreamConstrutor1() ;
        //testPrintStreamConstrutor2() ;
        //testPrintStreamConstrutor3() ;

        // 測試write(), print(), println(), printf()等介面。
        testPrintStreamAPIS() ;
    }

    /**
     * PrintStream(OutputStream out) 的測試函式
     *
     * 函式的作用，就是將字母“abcde”寫入到檔案“file.txt”中
     */
    private static void testPrintStreamConstrutor1() {
        // 0x61對應ASCII碼的字母'a'，0x62對應ASCII碼的字母'b', ...
        final byte[] arr={0x61, 0x62, 0x63, 0x64, 0x65 }; // abced
        try {
            // 建立檔案“file.txt”的File物件
            File file = new File("file.txt");
            // 建立檔案對應FileOutputStream
            PrintStream out = new PrintStream(
                    new FileOutputStream(file));
            // 將“位元組陣列arr”全部寫入到輸出流中
            out.write(arr);
            // 關閉輸出流
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * PrintStream(File file) 的測試函式
     *
     * 函式的作用，就是將字母“abcde”寫入到檔案“file.txt”中
     */
    private static void testPrintStreamConstrutor2() {
        final byte[] arr={0x61, 0x62, 0x63, 0x64, 0x65 };
        try {
            File file = new File("file.txt");
            PrintStream out = new PrintStream(file);
            out.write(arr);
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * PrintStream(String fileName) 的測試函式
     *
     * 函式的作用，就是將字母“abcde”寫入到檔案“file.txt”中
     */
    private static void testPrintStreamConstrutor3() {
        final byte[] arr={0x61, 0x62, 0x63, 0x64, 0x65 };
        try {
            PrintStream out = new PrintStream("file.txt");
            out.write(arr);
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 測試write(), print(), println(), printf()等介面。
     */
    private static void testPrintStreamAPIS() {
        // 0x61對應ASCII碼的字母'a'，0x62對應ASCII碼的字母'b', ...
        final byte[] arr={0x61, 0x62, 0x63, 0x64, 0x65 }; // abced
        try {
            // 建立檔案對應FileOutputStream
            PrintStream out = new PrintStream("other.txt");

            // 將字串“hello PrintStream”+回車符，寫入到輸出流中
            out.println("hello PrintStream");
            // 將0x41寫入到輸出流中
            // 0x41對應ASCII碼的字母'A'，也就是寫入字元'A'
            out.write(0x41);
            // 將字串"65"寫入到輸出流中。
            // out.print(0x41); 等價於 out.write(String.valueOf(0x41));
            out.print(0x41);
            // 將字元'B'追加到輸出流中
            out.append('B');

            // 將"CDE is 5" + 回車  寫入到輸出流中
            String str = "CDE";
            int num = 5;
            out.printf("%s is %d\n", str, num);

            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

執行上面的程式碼，會在原始碼所在目錄生成兩個檔案“file.txt”和“other.txt”。
file.txt的內容如下：

abcde

other.txt的內容如下：

hello PrintStream
A65BCDE is 5

原文：http://www.cnblogs.com/skywang12345/p/io_16.html

thinking in java (二十五) ----- IO之PrintStream

PrintStream介紹

原始碼分析

PrintStream和DataOutputStream異同點

示例程式碼

thinking in java (二十五) ----- IO之PrintStream

thinking in java (二十四) ----- IO之BufferedInputStream

thinking in java (二十九) ----- IO之 InputStreamReader和OutputStreamWriter

thinking in java (二十八) ----- IO之PipedReader和PipedWriter

thinking in java (二十七) ----- IO之CharArrayWriter(字元陣列輸出流)

thinking in java (二十七) ----- IO之CharArrayReader(字元陣列輸入流)

thinking in java (二十四) ----- IO之BufferedOutputStream

thinking in java (三十一) ----- IO之 BufferedWriter

thinking in java (二十) ----- IO之管道（PipedOutputStream和PipedInputStream）

thinking in java (二十二) ----- IO之序列化

thinking in java (二十六) ----- System.out.println("hello world")原理

讀thinking in java筆記(十五)：陣列

thinking in java (三十二) ----- IO之 PrintWriter

thinking in java (二十三) ----- IO之FileDescriptor

thinking in java (三十) ----- IO之 BufferedReader

thinking in java (三十) ----- IO之 FileReader和FileWriter

[隨筆][Java][讀書筆記][thinking in java][第十四章類型信息]

[隨筆][Java][讀書筆記][thinking in java][第十章內部類]

[隨筆][Java][讀書筆記][thinking in java][第十八章 Java I/O系統]

thinking in java (二) ----- 多型

thinking in java (二十五) ----- IO之PrintStream

PrintStream介紹

原始碼分析

PrintStream和DataOutputStream異同點

示例程式碼

相關推薦