PrinterWriter 源码分析

转自：http://www.fengfly.com/plus/view-214075-1.html

PrintWriter 是字符类型的打印输出流，它继承于Writer。
PrintStream 用于向文本输出流打印对象的格式化表示形式。它实现在 PrintStream 中的所有 print 方法。它不包含用于写入原始字节的方法，对于这些字节，程序应该使用未编码的字节流进行写入。

public class PrintWriter extends Writer {  
 
    protected Writer out;  
 
    // 自动flush  
    // 所谓“自动flush”，就是每次执行print(), println(), write()函数，都会调用flush()函数；  
    // 而“不自动flush”，则需要我们手动调用flush()接口。  
    private final boolean autoFlush;  
    // PrintWriter是否右产生异常。当PrintWriter有异常产生时，会被本身捕获，并设置trouble为true  
    private boolean trouble = false;  
    // 用于格式化的对象  
    private Formatter formatter;  
    private PrintStream psOut = null;  
 
    // 行分割符  
    private final String lineSeparator;  
 
    // 获取csn(字符集名字)对应的Chaset  
    private static Charset toCharset(String csn)  
        throws UnsupportedEncodingException  
    {  
        Objects.requireNonNull(csn, "charsetName");  
        try {  
            return Charset.forName(csn);  
        } catch (IllegalCharsetNameException|UnsupportedCharsetException unused) {  
            // UnsupportedEncodingException should be thrown  
            throw new UnsupportedEncodingException(csn);  
        }  
    }  
 
    // 将“Writer对象out”作为PrintWriter的输出流，默认不会自动flush，并且采用默认字符集。  
    public PrintWriter (Writer out) {  
        this(out, false);  
    }  
 
    // 将“Writer对象out”作为PrintWriter的输出流，autoFlush的flush模式，并且采用默认字符集。  
    public PrintWriter(Writer out, boolean autoFlush) {  
        super(out);  
        this.out = out;  
        this.autoFlush = autoFlush;  
        lineSeparator = java.security.AccessController.doPrivileged(  
            new sun.security.action.GetPropertyAction("line.separator"));  
    }  
 
    // 将“输出流对象out”作为PrintWriter的输出流，不自动flush，并且采用默认字符集。  
    public PrintWriter(OutputStream out) {  
        this(out, false);  
    }  
 
    // 将“输出流对象out”作为PrintWriter的输出流，autoFlush的flush模式，并且采用默认字符集。  
    public PrintWriter(OutputStream out, boolean autoFlush) {  
        // new OutputStreamWriter(out)：将“字节类型的输出流”转换为“字符类型的输出流”  
        // new BufferedWriter(...): 为输出流提供缓冲功能。  
        this(new BufferedWriter(new OutputStreamWriter(out)), autoFlush);  
 
        // save print stream for error propagation  
        if (out instanceof java.io.PrintStream) {  
            psOut = (PrintStream) out;  
        }  
    }  
 
    // 创建fileName对应的OutputStreamWriter，进而创建BufferedWriter对象；然后将该BufferedWriter作为PrintWriter的输出流，不自动flush，采用默认字符集。  
    public PrintWriter(String fileName) throws FileNotFoundException {  
        this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName))),  
             false);  
    }  
 
    // 创建fileName对应的OutputStreamWriter，进而创建BufferedWriter对象；然后将该BufferedWriter作为PrintWriter的输出流，不自动flush，采用字符集charset。  
    private PrintWriter(Charset charset, File file)  
        throws FileNotFoundException  
    {  
        this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), charset)),  
             false);  
    }  
 
    // 创建fileName对应的OutputStreamWriter，进而创建BufferedWriter对象；然后将该BufferedWriter作为PrintWriter的输出流，不自动flush，采用csn字符集。  
    public PrintWriter(String fileName, String csn)  
        throws FileNotFoundException, UnsupportedEncodingException  
    {  
        this(toCharset(csn), new File(fileName));  
    }  
 
    // 创建file对应的OutputStreamWriter，进而创建BufferedWriter对象；然后将该BufferedWriter作为PrintWriter的输出流，不自动flush，采用默认字符集。  
    public PrintWriter(File file) throws FileNotFoundException {  
        this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file))),  
             false);  
    }  
 
    // 创建file对应的OutputStreamWriter，进而创建BufferedWriter对象；然后将该BufferedWriter作为PrintWriter的输出流，不自动flush，采用csn字符集。  
    public PrintWriter(File file, String csn)  
        throws FileNotFoundException, UnsupportedEncodingException  
    {  
        this(toCharset(csn), file);  
    }  
 
    private void ensureOpen() throws IOException {  
        if (out == null)  
            throw new IOException("Stream closed");  
    }  
 
    // flush“PrintWriter输出流中的数据”。  
    public void flush() {  
        try {  
            synchronized (lock) {  
                ensureOpen();  
                out.flush();  
            }  
        }  
        catch (IOException x) {  
            trouble = true;  
        }  
    }  
 
    public void close() {  
        try {  
            synchronized (lock) {  
                if (out == null)  
                    return;  
                out.close();  
                out = null;  
            }  
        }  
        catch (IOException x) {  
            trouble = true;  
        }  
    }  
 
    // flush“PrintWriter输出流缓冲中的数据”，并检查错误  
    public boolean checkError() {  
        if (out != null) {  
            flush();  
        }  
        if (out instanceof java.io.PrintWriter) {  
            PrintWriter pw = (PrintWriter) out;  
            return pw.checkError();  
        } else if (psOut != null) {  
            return psOut.checkError();  
        }  
        return trouble;  
    }  
 
    protected void setError() {  
        trouble = true;  
    }  
 
    protected void clearError() {  
        trouble = false;  
    }  
 
    // 将字符c写入到“PrintWriter输出流”中。c虽然是int类型，但实际只会写入一个字符  
    public void write(int c) {  
        try {  
            synchronized (lock) {  
                ensureOpen();  
                out.write(c);  
            }  
        }  
        catch (InterruptedIOException x) {  
            Thread.currentThread().interrupt();  
        }  
        catch (IOException x) {  
            trouble = true;  
        }  
    }  
 
    // 将“buf中从off开始的len个字符”写入到“PrintWriter输出流”中。  
    public void write(char buf[], int off, int len) {  
        try {  
            synchronized (lock) {  
                ensureOpen();  
                out.write(buf, off, len);  
            }  
        }  
        catch (InterruptedIOException x) {  
            Thread.currentThread().interrupt();  
        }  
        catch (IOException x) {  
            trouble = true;  
        }  
    }  
 
    // 将“buf中的全部数据”写入到“PrintWriter输出流”中。  
    public void write(char buf[]) {  
        write(buf, 0, buf.length);  
    }  
 
    // 将“字符串s中从off开始的len个字符”写入到“PrintWriter输出流”中。  
    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;  
        }  
    }  
 
    // 将“字符串s”写入到“PrintWriter输出流”中。  
    public void write(String s) {  
        write(s, 0, s.length());  
    }  
 
    // 将“换行符”写入到“PrintWriter输出流”中。  
    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;  
        }  
    }  
 
    // 将“boolean数据对应的字符串”写入到“PrintWriter输出流”中，print实际调用的是write函数  
    public void print(boolean b) {  
        write(b ? "true" : "false");  
    }  
 
    // 将“字符c对应的字符串”写入到“PrintWriter输出流”中，print实际调用的是write函数  
    public void print(char c) {  
        write(c);  
    }  
 
    // 将“int数据i对应的字符串”写入到“PrintWriter输出流”中，print实际调用的是write函数  
    public void print(int i) {  
        write(String.valueOf(i));  
    }  
 
    // 将“long型数据l对应的字符串”写入到“PrintWriter输出流”中，print实际调用的是write函数  
    public void print(long l) {  
        write(String.valueOf(l));  
    }  
 
    // 将“float数据f对应的字符串”写入到“PrintWriter输出流”中，print实际调用的是write函数  
    public void print(float f) {  
        write(String.valueOf(f));  
    }  
 
    // 将“double数据d对应的字符串”写入到“PrintWriter输出流”中，print实际调用的是write函数  
    public void print(double d) {  
        write(String.valueOf(d));  
    }  
 
    // 将“字符数组s”写入到“PrintWriter输出流”中，print实际调用的是write函数  
    public void print(char s[]) {  
        write(s);  
    }  
 
    // 将“字符串数据s”写入到“PrintWriter输出流”中，print实际调用的是write函数  
    public void print(String s) {  
        if (s == null) {  
            s = "null";  
        }  
        write(s);  
    }  
 
    // 将“对象obj对应的字符串”写入到“PrintWriter输出流”中，print实际调用的是write函数  
    public void print(Object obj) {  
        write(String.valueOf(obj));  
    }  
 
    // 将“换行符”写入到“PrintWriter输出流”中，println实际调用的是write函数  
    public void println() {  
        newLine();  
    }  
 
    // 将“boolean数据对应的字符串+换行符”写入到“PrintWriter输出流”中，println实际调用的是write函数  
    public void println(boolean x) {  
        synchronized (lock) {  
            print(x);  
            println();  
        }  
    }  
 
    // 将“字符x对应的字符串+换行符”写入到“PrintWriter输出流”中，println实际调用的是write函数  
    public void println(char x) {  
        synchronized (lock) {  
            print(x);  
            println();  
        }  
    }  
 
    // 将“int数据对应的字符串+换行符”写入到“PrintWriter输出流”中，println实际调用的是write函数  
    public void println(int x) {  
        synchronized (lock) {  
            print(x);  
            println();  
        }  
    }  
 
    // 将“long数据对应的字符串+换行符”写入到“PrintWriter输出流”中，println实际调用的是write函数  
    public void println(long x) {  
        synchronized (lock) {  
            print(x);  
            println();  
        }  
    }  
 
    // 将“float数据对应的字符串+换行符”写入到“PrintWriter输出流”中，println实际调用的是write函数  
    public void println(float x) {  
        synchronized (lock) {  
            print(x);  
            println();  
        }  
    }  
 
    // 将“double数据对应的字符串+换行符”写入到“PrintWriter输出流”中，println实际调用的是write函数  
    public void println(double x) {  
        synchronized (lock) {  
            print(x);  
            println();  
        }  
    }  
 
    // 将“字符数组x+换行符”写入到“PrintWriter输出流”中，println实际调用的是write函数  
    public void println(char x[]) {  
        synchronized (lock) {  
            print(x);  
            println();  
        }  
    }  
 
    // 将“字符串x+换行符”写入到“PrintWriter输出流”中，println实际调用的是write函数  
    public void println(String x) {  
        synchronized (lock) {  
            print(x);  
            println();  
        }  
    }  
 
    // 将“对象o对应的字符串+换行符”写入到“PrintWriter输出流”中，println实际调用的是write函数  
    public void println(Object x) {  
        String s = String.valueOf(x);  
        synchronized (lock) {  
            print(s);  
            println();  
        }  
    }  
 
    // 将“数据args”根据“默认Locale值(区域属性)”按照format格式化，并写入到“PrintWriter输出流”中  
    public PrintWriter printf(String format, Object ... args) {  
        return format(format, args);  
    }  
 
    // 将“数据args”根据“Locale值(区域属性)”按照format格式化，并写入到“PrintWriter输出流”中  
    public PrintWriter printf(Locale l, String format, Object ... args) {  
        return format(l, format, args);  
    }  
 
    // 根据“默认的Locale值(区域属性)”来格式化数据  
    public PrintWriter format(String format, Object ... args) {  
        try {  
            synchronized (lock) {  
                ensureOpen();  
                if ((formatter == null)  
                    || (formatter.locale() != Locale.getDefault()))  
                    formatter = new Formatter(this);  
                formatter.format(Locale.getDefault(), format, args);  
                if (autoFlush)  
                    out.flush();  
            }  
        } catch (InterruptedIOException x) {  
            Thread.currentThread().interrupt();  
        } catch (IOException x) {  
            trouble = true;  
        }  
        return this;  
    }  
 
    // 根据“Locale值(区域属性)”来格式化数据  
    public PrintWriter format(Locale l, String format, Object ... args) {  
        try {  
            synchronized (lock) {  
                ensureOpen();  
                if ((formatter == null) || (formatter.locale() != l))  
                    formatter = new Formatter(this, l);  
                formatter.format(l, format, args);  
                if (autoFlush)  
                    out.flush();  
            }  
        } catch (InterruptedIOException x) {  
            Thread.currentThread().interrupt();  
        } catch (IOException x) {  
            trouble = true;  
        }  
        return this;  
    }  
 
    // 将“字符序列的全部字符”追加到“PrintWriter输出流中”  
    public PrintWriter append(CharSequence csq) {  
        if (csq == null)  
            write("null");  
        else 
            write(csq.toString());  
        return this;  
    }  
 
    // 将“字符序列从start(包括)到end(不包括)的全部字符”追加到“PrintWriter输出流中”  
    public PrintWriter append(CharSequence csq, int start, int end) {  
        CharSequence cs = (csq == null ? "null" : csq);  
        write(cs.subSequence(start, end).toString());  
        return this;  
    }  
 
    // 将“字符c”追加到“PrintWriter输出流中”  
    public PrintWriter append(char c) {  
        write(c);  
        return this;  
    }  
} 

示例见原文

最后

以上就是和谐月亮为你收集整理的PrinterWriter 源码分析的全部内容，希望文章能够帮你解决PrinterWriter 源码分析所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。