PrintStream是打印输出流,继承于FilterOutputStream,PrintStream是用来装饰其他输出流,为其他输出流添加功能,方便他们打印出各种数据值表示形式。与其他输出流不同,PrintStream永远不会抛出IOException,它产生的错误会被自身的函数所捕获并设置错误标记,用户可以通过checkError()返回错误标记,查看是否产生IOException。PrintStream提供了自动flush和字符集设置功能,写入的数据会立刻调用flush()函数。
PrintStream主要的函数列表:
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)
示例程序:
public class PrintStreamTest {

    public static void main(String[] args) {
        testPrintStreamConstrutor1() ;
        // 测试write(), print(), println(), printf()等接口。
        testPrintStreamAPIS() ;
    }
    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("file1.txt");
            // 创建文件对应FileOutputStream
            PrintStream out = new PrintStream(new FileOutputStream(file));
            // 将“字节数组arr”全部写入到输出流中
            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();
        }
    }
}
运行结果:
file1.txt文件中为: abcde
other.txt文件中为:
hello PrintStream
A65BCDE is 5

基于JDK8的PrintStream的源码:
is.charOut = new OutputStreamWriter(this);
        this.textOut = new BufferedWriter(charOut);
    }
    //out输出流,自动autoFlash,charset字符集
    private PrintStream(boolean autoFlush, OutputStream out, Charset charset) {
        super(out);
        this.autoFlush = autoFlush;
        this.charOut = new OutputStreamWriter(this, charset);
        this.textOut = new BufferedWriter(charOut);
    }

    /* Variant of the private constructor so that the given charset name
     * can be verified before evaluating the OutputStream argument. Used
     * by constructors creating a FileOutputStream that also take a
     * charset name.
     */
    private PrintStream(boolean autoFlush, Charset charset, OutputStream out) throws UnsupportedEncodingException
    {
        this(autoFlush, out, charset);
    }
    //out输出流,不会自动flush,m默认字符集
    public PrintStream(OutputStream out) {
        this(out, false);
    }
    public PrintStream(OutputStream out, boolean autoFlush) {
        this(autoFlush, requireNonNull(out, "Null output stream"));
    }

    public PrintStream(OutputStream out, boolean autoFlush, String encoding) throws UnsupportedEncodingException
    {
        this(autoFlush,
        requireNonNull(out, "Null output stream"),
        toCharset(encoding));
    }
    //将FileOutputStream作为输入流,不自动flush,默认字符集
    public PrintStream(String fileName) throws FileNotFoundException {
        this(false, new FileOutputStream(fileName));
    }
    //FileOutputStream输出流,不自动flush,csn字符集
    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));
    }
    //FileOutputStream输出流,不自动flush,默认字符集
    public PrintStream(File file) throws FileNotFoundException {
        this(false, new FileOutputStream(file));
    }
    //FileOutputStream输出流,csn字符集,不自动flush
    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));
    }

    /** Check to make sure that the stream has not been closed */
    //输出流不为空
    private void ensureOpen() throws IOException {
        if (out == null)
            throw new IOException("Stream closed");
    }
    //刷新
    public void flush() {
        synchronized (this) {
            try {
                ensureOpen();
                out.flush();
            }
            catch (IOException x) {
                trouble = true;
            }
        }
    }

    private boolean closing = false; /* To avoid recursive closing */
    //关闭输出流
    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;
    }

    /*
     * Exception-catching, synchronized output operations,
     * which also implement the write() methods of OutputStream
     */

    //将数据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;
        }
    }

    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;
        }
    }

    /*
     * The following private methods on the text- and character-output streams
     * always flush the stream buffers, so that writes to the underlying byte
     * stream occur as promptly as with the original PrintStream.
     */
    //将b中的全部数据写入到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;
        }
    }
    //String写到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;
        }
    }

    /* Methods that do not terminate lines */

    //将b对应的字符串写到PrintStream中
    public void print(boolean b) {
        write(b ? "true" : "false");
    }

    //最后都是转化为String

    //字符串
    public void print(char c) {
        write(String.valueOf(c));
    }
    //int类型
    public void print(int i) {
        write(String.valueOf(i));
    }
    //long类型
    public void print(long l) {
        write(String.valueOf(l));
    }
    //float
    public void print(float f) {
        write(String.valueOf(f));
    }
    //double
    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));
    }

    /* Methods that do terminate lines */
    //换行
    public void println() {
        newLine();
    }
    //boolean+换行
    public void println(boolean x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    //char+换行
    public void println(char x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    //int+换行
    public void println(int x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    //long+换行
    public void println(long x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    //float+换行
    public void println(float x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    //double+换行
    public void println(double x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
    //char数组+换行
    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();
        }
    }

    public PrintStream printf(String format, Object ... args) {
            return format(format, args);
    }

    public PrintStream printf(Locale l, String format, Object ... args) {
        return format(l, format, args);
    }
    // 将“数据args”根据“默认Locale值(区域属性)”按照format格式化,并写入到“PrintStream输出流”中
    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;
    }
    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;
    }

    public PrintStream append(CharSequence csq) {
        if (csq == null)
            print("null");
        else
            print(csq.toString());
        return this;
    }
    public PrintStream append(CharSequence csq, int start, int end) {
        CharSequence cs = (csq == null ? "null" : csq);
        write(cs.subSequence(start, end).toString());
        return this;
    }
    public PrintStream append(char c) {
        print(c);
        return this;
    }

}

Java-IO之PrintStream(打印输出流)的更多相关文章

  1. java io系列16之 PrintStream(打印输出流)详解

    本章介绍PrintStream以及 它与DataOutputStream的区别.我们先对PrintStream有个大致认识,然后再深入学习它的源码,最后通过示例加深对它的了解. 转载请注明出处:htt ...

  2. Java中PrintStream(打印输出流)

    Java中PrintStream(打印输出流)   PrintStream 是打印输出流,它继承于FilterOutputStream. PrintStream 是用来装饰其它输出流.它能为其他输出流 ...

  3. java的PrintStream(打印输出流)详解(java_io)

    java的PrintStream(打印输出流)详解(java_io) 本章介绍PrintStream以及 它与DataOutputStream的区别.我们先对PrintStream有个大致认识,然后再 ...

  4. Java Io(数据输入输出流)

    Java Io 字节流中的DataInputStream 和 DataOutputStream,使用流更加方便,是流的一个扩展,更方便读取int, long,字符等类型数据. 事例代码如下: pack ...

  5. Java Io 流(输入输出流)

    IO流,也就是输入和输出流,可分为字节流和字符流. 1. 字节流 (1). InputStream 输入流,用于读取文件 输入流常用API: inputStream.read()  读取一个字节 in ...

  6. java IO流 之 字节输出流 OutputString()

    Java学习重点之一:OutputStream 字节输出流的使用 FileOutPutStream:子类,写出数据的通道 步骤: 1.获取目标文件 2.创建通道(如果原来没有目标文件,则会自动创建一个 ...

  7. 系统学习 Java IO (一)----输入流和输出流 InputStream/OutputStream

    目录:系统学习 Java IO ---- 目录,概览 InputStream 是Java IO API中所有输入流的父类. 表示有序的字节流,换句话说,可以将 InputStream 中的数据作为有序 ...

  8. 缓冲字符流 java.io.BufferedWriter ,java.io.BufferedReader,缓冲字符输出流:PrintWriter

    package seday07; import java.io.IOException;import java.io.PrintWriter; /*** @author xingsir * 缓冲字符流 ...

  9. Java IO流之打印流与标准流

    一.打印流 1.1打印流特点与构造方法 1)PrintStream和PrintWriter类都提供了一系列重载的print和println方法来输出各种类型的数据. 2)PrintStream和Pri ...

  10. java ->IO流_打印流

    打印流的概述 打印流添加输出数据的功能,使它们能够方便地打印各种数据值表示形式. 打印流根据流的分类: 永远不会抛出IO异常 l  字节打印流  PrintStream l  字符打印流  Print ...

随机推荐

  1. HTTPS介绍

    超文本传输协议HTTP协议被用于在Web浏览器和网站服务器之间传递信息,HTTP协议以明文方式发送内容,不提供任何方式的数据加密,如果攻击者截取了Web浏览器和网站服务器之间的传输报文,就可以直接读懂 ...

  2. Spring MVC - 表单处理示例

    环境搭建 环境: Intellij IDEA Spring MVC 完整的项目文件结构如下所示: Student.java package com.ktao.controller; public cl ...

  3. App上架应用市场,如何攻破安全过检难题

    App的安全过检与众所熟知的安全检测是两个完全不同的概念.首先App行业本身对App安全过检有一定的要求与规范,其次2017年6月1日正式实施的<中国网络安全法>中就曾要求App在渠道上线 ...

  4. AngularJs开发——指令与控制器间的通信

    (原文:http://www.html5jscss.com/controller-between-directive.html) 指令与控制器之间通信,跟控制器间的通信.指令间通信也类似,也是下几种方 ...

  5. Spring boot集成swagger2

    一.Swagger2是什么? Swagger 是一款RESTFUL接口的文档在线自动生成+功能测试功能软件. Swagger 是一个规范和完整的框架,用于生成.描述.调用和可视化 RESTful 风格 ...

  6. JavaScript正则表达式模式匹配(2)——分组模式匹配

    var pattern=/google{4,8}$/; // {4,8}$表示匹配结尾4-8次 var str='googleeeeeeeee'; // 表示e的4-8次 alert(pattern. ...

  7. String字符串的操作

    字符串的常用操作 # Author:nadech name = "my name is nadech" print(name.count("a")) print ...

  8. springMVC源码分析--ModelAndViewContainer和ModelMap

    ModelAndViewContainer主要是用来返回Model对象的,在ModelAndViewContainer中有defaultModel和redirectModel, defaultMode ...

  9. chrome官方完整安装包

    But did you know Google allows you to download the full standalone installer of Chrome from its offi ...

  10. 手势监听GestureDetector 案例

    以下只做长按和甩出(用户按下朝某一方向甩动手指)案例 OnGestureListener可以查看到更多的手势事件 案例 package com.qf.mobliesafe.activity; impo ...