当前位置:天才代写 > tutorial > JAVA 教程 > java io进修(十五) 打印输出流详解

java io进修(十五) 打印输出流详解

2017-11-02 08:00 星期四 所属: JAVA 教程 浏览:61

副标题#e#

PrintStream(打印输出流)详解

PrintStream 先容

PrintStream 是打印输出流,它担任于FilterOutputStream。

PrintStream 是用来装饰其它输出流。它能为其他输出流添加了成果,使它们可以或许利便地打印各类数据值暗示形式。

与其他输出流差异,PrintStream 永远不会抛出 IOException;它发生的IOException会被自身的函数所捕捉并配置错误标志, 用户可以通过 checkError() 返回错误标志,从而查察PrintStream内部是否发生了IOException。

别的,PrintStream 提供了自动flush 和 字符集配置成果。所谓自动flush,就是往PrintStream写入的数据会立即挪用flush()函数。

PrintStream 函数列表

/* 
 * 结构函数
 */
// 将“输出流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)


#p#副标题#e#

留意:print()和println()都是将个中参数转换成字符串之后,再写入到输入流。

譬喻,

print(0x61);

等价于

write(String.valueOf(0x61));

上面语句是将字符串"97"写入到输出流。0x61对应十进制数是97。

write(0x61)

上面语句是将字符’a’写入到输出流。因为0x61对应的ASCII码的字母’a’。

查察下面的代码,我们能对这些函数有更清晰的认识!

#p#分页标题#e#

PrintStream 源码阐明(基于jdk1.7.40)

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函数
	// 查察本栏目

说明:

#p#分页标题#e#

PrintStream的源码较量简朴,请上文的注释举办阅读。若有不大白的处所,发起先看看后头的PrintStream利用示例;待搞清它的浸染和用法之后,再来阅读源码。

PrintStream和DataOutputStream异同点

沟通点:都是担任与FileOutputStream,用于包装其它输出流。

差异点:

(01) PrintStream和DataOutputStream 都可以将数据名目化输出;但它们在“输出字符串”时的编码差异。

PrintStream是输出时回收的是用户指定的编码(建设PrintStream时指定的),若没有指定,则回收系统默认的字符编码。而DataOutputStream则回收的是UTF-8。

关于UTF-8的字符编码可以参考“字符编码(ASCII,Unicode和UTF-8) 和 巨细端”

关于DataOutputStream的更多内容,可以参考“java io系列15之 DataOutputStream(数据输出流)的认知、源码和示例”

(02) 它们的写入数据时的异常处理惩罚机制差异。

DataOutputStream在通过write()向“输出流”中写入数据时,若发生IOException,会抛出。

#p#分页标题#e#

而PrintStream在通过write()向“输出流”中写入数据时,若发生IOException,则会在write()中举办捕捉处理惩罚;并配置trouble标志(用于暗示发生了异常)为true。用户可以通过checkError()返回trouble值,从而查抄输出流中是否发生了异常。

(03) 结构函数差异

DataOutputStream的结构函数只有一个:DataOutputStream(OutputStream out)。即它只支持以输出流out作为“DataOutputStream的输出流”。

#p#分页标题#e#

而PrintStream的结构函数有很多:和DataOutputStream一样,支持以输出流out作为“PrintStream输出流”的结构函数;还支持以“File工具”可能“String范例的文件名工具”的结构函数。

并且,在PrintStream的结构函数中,能“指定字符集”和“是否支持自动flush()操纵”。

(04) 目标差异

DataOutputStream的浸染是装饰其它的输出流,它和DataInputStream共同利用:答允应用措施以与呆板无关的方法从底层输入流中读写java数据范例。

而PrintStream的浸染固然也是装饰其他输出流,可是它的目标不是以与呆板无关的方法从底层读写java数据范例;而是为其它输出流提供打印各类数据值暗示形式,使其它输出流能利便的通过print(), println()或printf()等输出各类名目标数据。

示例代码

关于PrintStream中API的具体用法,参考示例代码(PrintStreamTest.java):

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

 

    关键字:


天才代写-代写联系方式