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

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