【Java基礎知識】IO流--標準輸入輸出流、列印流PrintStream

Windsor90發表於2017-01-21

1 標準輸入流

public static final InputStream in："標準"輸入流。

此流已開啟並準備提供輸入資料。通常，此流對應於鍵盤輸入或者由主機環境或使用者指定的另一個輸入源。
從鍵盤獲取資料的3種方式：
（1）main方法的args接收引數：java param1 param2 Xxx. java
（2）通過使用Scanner類【Jdk 1.5版本後】
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
int x = sc.nextInt()
（3）通過字元緩衝流包裝標準輸入流，來實現
把位元組流轉換成字元流，然後通過字元緩衝流操作。
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
使用案例：通過字元緩衝流來獲取鍵盤錄入的資料。

public class SystemInDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("請輸入一個字串：");
        String line = br.readLine();
        System.out.println("你輸入的字串是：" + line);
        System.out.println("請輸入一個整數：");
        // int i = Integer.parseInt(br.readLine());
        line = br.readLine();
        int i = Integer.parseInt(line);
        System.out.println("你輸入的整數是：" + i);
    }
}

2 標準輸出流

public static final PrintStream out："標準"輸出流。
標準輸出流的例項是列印流【PrintStream】。

此流已開啟並準備接受輸出資料。通常，此流對應於顯示器輸出或者由主機環境或使用者指定的另一個輸出目標。

public class SystemOutDemo {
    public static void main(String[] args) {
        System.out.println("Java");
        // 獲取標準輸出流物件
        PrintStream ps = System.out;
        ps.println("Java");
        ps.println();
    }
}

3 列印流PrintStream、PrintWriter

PrintStream類提供了一系列的print和println()方法，可以實現將基本型別的格式化成字串輸出。
System.out就是PrintStream類的一個例項物件。

3.1 位元組列印流PrintStream

建構函式：

PrintStream(OutputStream out)
PrintStream(OutputStream out,boolean auotflush)
PrintStream(OutputStream out,boolean auotflush， String encoding)

其中autoflush控制在Java中遇到換行符(\n)時是否自動清空緩衝區,encoding是指定編碼方式。println方法與print方法的區別是：println()等於print(“\n”)。Java的PrintStream物件具有多個過載的print和println方法，它們可輸出各種型別(包括Object)的資料。對於基本資料型別的資料,print和println方法會先將它們轉換成字串的形式後再輸出,而不是輸出原始的位元組內容,對於一個非基本資料型別的物件,print和println方法會先呼叫物件的toString方法，然後再輸出toString方法返回的字串。
【PrintStream原始碼部分內容分析:】

public class PrintStream extends FilterOutputStream{

    private final boolean autoFlush;
    private boolean trouble = false;
    private BufferedWriter textOut; //字元緩衝流
    private OutputStreamWriter charOut; //轉換流，作為字元緩衝流的引數

    //建立不帶自動重新整理的列印流。
    public PrintStream(OutputStream out) {
        this(out, false);
    }
    //建立可設定自動重新整理的列印流
    public PrintStream(OutputStream out, boolean autoFlush) {
        this(autoFlush, requireNonNull(out, "Null output stream"));
    }
    //建立給定autoFlush和encoding的列印流
    public PrintStream(OutputStream out, boolean autoFlush, String encoding)
        throws UnsupportedEncodingException{
        this(autoFlush,requireNonNull(out, "Null output stream"),toCharset(encoding));           
    }   

    /* 私有構造 */
    private PrintStream(boolean autoFlush, OutputStream out) {
        super(out);
        this.autoFlush = autoFlush;
        this.charOut = new OutputStreamWriter(this);
        this.textOut = new BufferedWriter(charOut);
    }
    /* 私有構造 */
    private PrintStream(boolean autoFlush, OutputStream out, Charset charset) {
        super(out);
        this.autoFlush = autoFlush;
        this.charOut = new OutputStreamWriter(this, charset);
        this.textOut = new BufferedWriter(charOut);
    }       
    /*檢測IO流物件，確定IO是開啟的狀態 */
    private void ensureOpen() throws IOException {
        if (out == null) throw new IOException("Stream closed");      
    }
    //重新整理IO流
    public void flush() {
        synchronized (this) {
            try {
                ensureOpen();
                out.flush();
            }
            catch (IOException x) {
                trouble = true;
            }
        }
    }
    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;
        }
    }
    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;
        }
    }
    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;
        }
    }
    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;
        }
    }
    //換行，根據flushBuffer設定，選擇是否自動重新整理
    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;
        }
    }
    /*以下是print(X x)方法的過載*/
    public void print(boolean b) {
        write(b ? "true" : "false");
    }
    public void print(char c) {
        write(String.valueOf(c));
    }
    public void print(int i) {
        write(String.valueOf(i));
    }
    public void print(long l) {
        write(String.valueOf(l));
    }
    public void print(float f) {
        write(String.valueOf(f));
    }
    public void print(double d) {
        write(String.valueOf(d));
    }
    public void print(char s[]) {
        write(s);
    }
    public void print(String s) {
        if (s == null) {
            s = "null";
        }
        write(s);
    }
    public void print(Object obj) {
        write(String.valueOf(obj));
    }
    //換行
    public void println() {
        newLine();
    }
    /*以下是println(X x)方法的過載*/
    public void println(boolean x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(char x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(int x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(long x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(float x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(double x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(char x[]) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(String x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    public void println(Object x) {
        String s = String.valueOf(x);
        synchronized (this) {
            print(s);
            newLine();
        }
    }
}

3.2 字元列印流PrintWriter

IO包中提供了一個與PrintStream對應的PrintWriter類，PrintWriter即使遇到換行符(\n)也不會自動清空緩衝區，只在設定了autoflush模式下使用了println方法後才自動清空緩衝區。 PrintWriter相對PrintStream最有利的一個地方就是println方法的行為，在Windows的文字換行是”\r\n”，而Linux下的文字換行是”\n”,如果我們希望程式能夠生成平臺相關的文字換行,而不是在各種平臺下都用”\n”作為文字換行,我們就應該使用PrintWriter的println方法時,PrintWriter的println方法能根據不同的作業系統而生成相應的換行符。
【PrintWriter原始碼部分內容分析:】
位元組流的print(), println()方法的原始碼分析，實際上底層呼叫的是該類成員變數，Writer類物件out的write()方法。out成員變數通過構造初始化。

位元組流的print(), println()方法的原始碼分析，實際上底層呼叫的是
該類成員變數，Writer類物件out的write()方法。out成員變數通過構造初始化。
public class PrintWriter extends Writer{
    protected Writer out;
    private final boolean autoFlush;//是否自動重新整理
    /*
    如果為 true，則每當寫入 byte 陣列、呼叫其中一個 println 方法
    或寫入換行符或位元組 ('\n') 時都會重新整理輸出緩衝區
    */
    private boolean trouble = false;    
    public PrintWriter (Writer out) {
        this(out, false);
    }
    public PrintWriter(Writer out,boolean autoFlush) {                  
        super(out);
        this.out = out;
        this.autoFlush = autoFlush;     
    }
    /*print()可以操作任何型別的資料，下面，
      我們看看原始碼中各種型別資料的處理 */
    public void print(String s) {
        if (s == null) { s = "null"; }
        write(s);
    }
    public void write(String s) {
        write(s, 0, s.length());
    }
    //呼叫字元流out的write方法
    public void write(String s, int off, int len) {
        try {
            synchronized (lock) {
                ensureOpen();
                out.write(s, off, len);
            }
        }
        catch (InterruptedIOException x) {
            Thread.currentThread().interrupt();
        }
        catch (IOException x) {
            trouble = true;
        }
    }
    /*檢查out,確保流是開啟的*/
    private void ensureOpen() throws IOException {
        if (out == null)
            throw new IOException("Stream closed");
    }   
    /*
     print()可以操作,boolean,int,long, float, double,chae[]
     Object等型別
    */
    public void print(boolean b) {
        write(b ? "true" : "false");
    }
    public void print(char c) {
        write(c);
    }
    public void print(int i) {
        write(String.valueOf(i));
    }   
    public void print(long l) {
        write(String.valueOf(l));
    }   
    public void print(float f) {
        write(String.valueOf(f));
    }   
    public void print(double d) {
        write(String.valueOf(d));
    }   
    public void print(char s[]) {
        write(s);
    }
    public void print(Object obj) {
        write(String.valueOf(obj));
    }
/*println()換行，原始碼分析:如果autoFlush為true
則呼叫println()還啟用了自動重新整理的功能。
*/
    public void println() {
        newLine();
    }
    private void newLine() {
        try {
            synchronized (lock) {
                ensureOpen();
                out.write(lineSeparator);
                if (autoFlush)
                    out.flush();
            }
        }
        catch (InterruptedIOException x) {
            Thread.currentThread().interrupt();
        }
        catch (IOException x) {
            trouble = true;
        }
    }   
}

[java IO流]之萬能輸出流列印流printWriter
2021-02-10
Java
[java IO流]之基本資料型別輸入輸出流
2021-02-10
Java資料型別
Java&Android 基礎知識梳理(6) 位元組輸入輸出流
2017-12-21
JavaAndroid
IO流的位元組輸入輸出流（InputStream,OutputStream）
2021-12-03
[java IO流]之鍵盤顯示器輸入輸出流（System）
2021-02-10
Java
Java 輸入輸出流
2018-12-23
Java
JAVA輸入輸出流
2015-08-04
Java
詳解Java中的IO輸入輸出流！
2020-12-18
Java
Java之IO流基礎流物件
2014-12-28
Java物件
Java基礎知識回顧之六 —– IO流
2019-03-03
Java
Java基礎知識回顧之六 ----- IO流
2018-06-16
Java
JAVA_基礎IO流物件流（三）
2021-01-04
Java物件
重學java中的輸入輸出流
2020-11-24
Java
c++入門：輸入輸出流
2016-12-26
C++
Java基礎（八）——IO流1_位元組流、字元流
2021-12-28
Java字元
Java中資料輸入輸出流——DataInputStream和DataOutputStream
2017-11-22
JavaAI
java中基本輸入輸出流的解釋
2005-07-11
Java
Java基礎 Java-IO流深入淺出
2021-04-16
Java
Java基礎（八）——IO流2_緩衝流、轉換流
2022-01-01
Java
[C++]輸入/輸出流類庫
2016-12-14
C++
C++ 中輸入輸出流及檔案流操作筆記
2016-09-11
C++筆記
023--C++養成之路（io流：流的初始化以及基本的輸入輸出）
2020-10-04
C++
IO流下：位元組流、流操作規律(java基礎)
2015-10-10
Java
Java —— 標準輸入輸出
2018-10-28
Java
Java零基礎學java之IO流--05InputStream位元組輸入流
2021-07-08
Java
Java知識點總結——IO流框架
2021-12-11
Java框架
資料流輸出
2018-09-13
如何把檔案輸出流替換成位元組輸出流
2020-11-24
android基礎學習-java篇day10-step3-第六節：java輸入輸出流
2018-09-13
AndroidJava
C++中的檔案輸入/輸出（3）：掌握輸入/輸出流 (轉)
2007-11-13
C++
java基礎學習_io流之FileInputStream
2019-08-03
Java
Java中IO流的知識點總結
2020-10-04
Java
檔案輸入輸出處理(二)-位元組流
2022-06-19
流媒體技術基礎-流媒體傳輸協議(二)
2016-07-11
協議
Java基礎輸入輸出
2024-03-11
Java
java -IO流
2020-06-01
Java
Java IO流
2021-05-13
Java
java - IO流
2020-12-25
Java