Java 中的Printstream介绍_动力节点Java学院整理

2024-02-22 20:17:03 54

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(OutputStreamout)
//将“输出流out”作为PrintStream的输出流，自动flush，并且采用默认字符集。
PrintStream(OutputStreamout,booleanautoFlush)
//将“输出流out”作为PrintStream的输出流，自动flush，采用charsetName字符集。
PrintStream(OutputStreamout,booleanautoFlush,StringcharsetName)
//创建file对应的FileOutputStream，然后将该FileOutputStream作为PrintStream的输出流，不自动flush，采用默认字符集。
PrintStream(Filefile)
//创建file对应的FileOutputStream，然后将该FileOutputStream作为PrintStream的输出流，不自动flush，采用charsetName字符集。
PrintStream(Filefile,StringcharsetName)
//创建fileName对应的FileOutputStream，然后将该FileOutputStream作为PrintStream的输出流，不自动flush，采用默认字符集。
PrintStream(StringfileName)
//创建fileName对应的FileOutputStream，然后将该FileOutputStream作为PrintStream的输出流，不自动flush，采用charsetName字符集。
PrintStream(StringfileName,StringcharsetName)
//将“字符c”追加到“PrintStream输出流中”
PrintStreamappend(charc)
//将“字符序列从start(包括)到end(不包括)的全部字符”追加到“PrintStream输出流中”
PrintStreamappend(CharSequencecharSequence,intstart,intend)
//将“字符序列的全部字符”追加到“PrintStream输出流中”
PrintStreamappend(CharSequencecharSequence)
//flush“PrintStream输出流缓冲中的数据”，并检查错误
booleancheckError()
//关闭“PrintStream输出流”
synchronizedvoidclose()
//flush“PrintStream输出流缓冲中的数据”。
//例如，PrintStream装饰的是FileOutputStream，则调用flush时会将数据写入到文件中
synchronizedvoidflush()
//根据“Locale值(区域属性)”来格式化数据
PrintStreamformat(Localel,Stringformat,Object...args)
//根据“默认的Locale值(区域属性)”来格式化数据
PrintStreamformat(Stringformat,Object...args)
//将“float数据f对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
voidprint(floatf)
//将“double数据d对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
voidprint(doubled)
//将“字符串数据str”写入到“PrintStream输出流”中，print实际调用的是write函数
synchronizedvoidprint(Stringstr)
//将“对象o对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
voidprint(Objecto)
//将“字符c对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
voidprint(charc)
//将“字符数组chars对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
voidprint(char[]chars)
//将“long型数据l对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
voidprint(longl)
//将“int数据i对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
voidprint(inti)
//将“boolean数据b对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
voidprint(booleanb)
//将“数据args”根据“Locale值(区域属性)”按照format格式化，并写入到“PrintStream输出流”中
PrintStreamprintf(Localel,Stringformat,Object...args)
//将“数据args”根据“默认Locale值(区域属性)”按照format格式化，并写入到“PrintStream输出流”中
PrintStreamprintf(Stringformat,Object...args)
//将“换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
voidprintln()
//将“float数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
voidprintln(floatf)
//将“int数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
voidprintln(inti)
//将“long数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
voidprintln(longl)
//将“对象o对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
voidprintln(Objecto)
//将“字符数组chars对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
voidprintln(char[]chars)
//将“字符串str+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
synchronizedvoidprintln(Stringstr)
//将“字符c对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
voidprintln(charc)
//将“double数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
voidprintln(doubled)
//将“boolean数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
voidprintln(booleanb)
//将数据oneByte写入到“PrintStream输出流”中。oneByte虽然是int类型，但实际只会写入一个字节
synchronizedvoidwrite(intoneByte)
//将“buffer中从offset开始的length个字节”写入到“PrintStream输出流”中。
voidwrite(byte[]buffer,intoffset,intlength)

注意：print()和println()都是将其中参数转换成字符串之后，再写入到输入流。

例如，

print(0x61);

等价于

write(String.valueOf(0x61));

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

write(0x61)

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

查看下面的代码，我们能对这些函数有更清晰的认识！

PrintStream源码分析(基于jdk1.7.40)

packagejava.io;
importjava.util.Formatter;
importjava.util.Locale;
importjava.nio.charset.Charset;
importjava.nio.charset.IllegalCharsetNameException;
importjava.nio.charset.UnsupportedCharsetException;
publicclassPrintStreamextendsFilterOutputStream
implementsAppendable,Closeable
{
//自动flush
//所谓“自动flush”，就是每次执行print(),println(),write()函数，都会调用flush()函数；
//而“不自动flush”，则需要我们手动调用flush()接口。
privatefinalbooleanautoFlush;
//PrintStream是否右产生异常。当PrintStream有异常产生时，会被本身捕获，并设置trouble为true
privatebooleantrouble=false;
//用于格式化的对象
privateFormatterformatter;
//BufferedWriter对象，用于实现“PrintStream支持字符集”。
//因为PrintStream是OutputStream的子类，所以它本身不支持字符串；
//但是BufferedWriter支持字符集，因此可以通过OutputStreamWriter创建PrintStream对应的BufferedWriter对象，从而支持字符集。
privateBufferedWritertextOut;
privateOutputStreamWritercharOut;
privatestaticTrequireNonNull(Tobj,Stringmessage){
if(obj==null)
thrownewNullPointerException(message);
returnobj;
}
//返回csn对应的字符集对象
privatestaticCharsettoCharset(Stringcsn)
throwsUnsupportedEncodingException
{
requireNonNull(csn,"charsetName");
try{
returnCharset.forName(csn);
}catch(IllegalCharsetNameException|UnsupportedCharsetExceptionunused){
//UnsupportedEncodingExceptionshouldbethrown
thrownewUnsupportedEncodingException(csn);
}
}
//将“输出流out”作为PrintStream的输出流，autoFlush的flush模式，并且采用默认字符集。
privatePrintStream(booleanautoFlush,OutputStreamout){
super(out);
this.autoFlush=autoFlush;
this.charOut=newOutputStreamWriter(this);
this.textOut=newBufferedWriter(charOut);
}
//将“输出流out”作为PrintStream的输出流，自动flush，采用charsetName字符集。
privatePrintStream(booleanautoFlush,OutputStreamout,Charsetcharset){
super(out);
this.autoFlush=autoFlush;
this.charOut=newOutputStreamWriter(this,charset);
this.textOut=newBufferedWriter(charOut);
}
//将“输出流out”作为PrintStream的输出流，自动flush，采用charsetName字符集。
privatePrintStream(booleanautoFlush,Charsetcharset,OutputStreamout)
throwsUnsupportedEncodingException
{
this(autoFlush,out,charset);
}
//将“输出流out”作为PrintStream的输出流，不会自动flush，并且采用默认字符集
publicPrintStream(OutputStreamout){
this(out,false);
}
//将“输出流out”作为PrintStream的输出流，自动flush，并且采用默认字符集。
publicPrintStream(OutputStreamout,booleanautoFlush){
this(autoFlush,requireNonNull(out,"Nulloutputstream"));
}
//将“输出流out”作为PrintStream的输出流，自动flush，采用charsetName字符集。
publicPrintStream(OutputStreamout,booleanautoFlush,Stringencoding)
throwsUnsupportedEncodingException
{
this(autoFlush,
requireNonNull(out,"Nulloutputstream"),
toCharset(encoding));
}
//创建fileName对应的FileOutputStream，然后将该FileOutputStream作为PrintStream的输出流，不自动flush，采用默认字符集。
publicPrintStream(StringfileName)throwsFileNotFoundException{
this(false,newFileOutputStream(fileName));
}
//创建fileName对应的FileOutputStream，然后将该FileOutputStream作为PrintStream的输出流，不自动flush，采用charsetName字符集。
publicPrintStream(StringfileName,Stringcsn)
throwsFileNotFoundException,UnsupportedEncodingException
{
//ensurecharsetischeckedbeforethefileisopened
this(false,toCharset(csn),newFileOutputStream(fileName));
}
//创建file对应的FileOutputStream，然后将该FileOutputStream作为PrintStream的输出流，不自动flush，采用默认字符集。
publicPrintStream(Filefile)throwsFileNotFoundException{
this(false,newFileOutputStream(file));
}
//创建file对应的FileOutputStream，然后将该FileOutputStream作为PrintStream的输出流，不自动flush，采用csn字符集。
publicPrintStream(Filefile,Stringcsn)
throwsFileNotFoundException,UnsupportedEncodingException
{
//ensurecharsetischeckedbeforethefileisopened
this(false,toCharset(csn),newFileOutputStream(file));
}
privatevoidensureOpen()throwsIOException{
if(out==null)
thrownewIOException("Streamclosed");
}
//flush“PrintStream输出流缓冲中的数据”。
//例如，PrintStream装饰的是FileOutputStream，则调用flush时会将数据写入到文件中
publicvoidflush(){
synchronized(this){
try{
ensureOpen();
out.flush();
}
catch(IOExceptionx){
trouble=true;
}
}
}
privatebooleanclosing=false;/*Toavoidrecursiveclosing*/
//关闭PrintStream
publicvoidclose(){
synchronized(this){
if(!closing){
closing=true;
try{
textOut.close();
out.close();
}
catch(IOExceptionx){
trouble=true;
}
textOut=null;
charOut=null;
out=null;
}
}
}
//flush“PrintStream输出流缓冲中的数据”，并检查错误
publicbooleancheckError(){
if(out!=null)
flush();
if(outinstanceofjava.io.PrintStream){
PrintStreamps=(PrintStream)out;
returnps.checkError();
}
returntrouble;
}
protectedvoidsetError(){
trouble=true;
}
protectedvoidclearError(){
trouble=false;
}
//将数据b写入到“PrintStream输出流”中。b虽然是int类型，但实际只会写入一个字节
publicvoidwrite(intb){
try{
synchronized(this){
ensureOpen();
out.write(b);
if((b=='\n')&&autoFlush)
out.flush();
}
}
catch(InterruptedIOExceptionx){
Thread.currentThread().interrupt();
}
catch(IOExceptionx){
trouble=true;
}
}
//将“buf中从off开始的length个字节”写入到“PrintStream输出流”中。
publicvoidwrite(bytebuf[],intoff,intlen){
try{
synchronized(this){
ensureOpen();
out.write(buf,off,len);
if(autoFlush)
out.flush();
}
}
catch(InterruptedIOExceptionx){
Thread.currentThread().interrupt();
}
catch(IOExceptionx){
trouble=true;
}
}
//将“buf中的全部数据”写入到“PrintStream输出流”中。
privatevoidwrite(charbuf[]){
try{
synchronized(this){
ensureOpen();
textOut.write(buf);
textOut.flushBuffer();
charOut.flushBuffer();
if(autoFlush){
for(inti=;i=))
out.flush();
}
}
catch(InterruptedIOExceptionx){
Thread.currentThread().interrupt();
}
catch(IOExceptionx){
trouble=true;
}
}
//将“换行符”写入到“PrintStream输出流”中。
privatevoidnewLine(){
try{
synchronized(this){
ensureOpen();
textOut.newLine();
textOut.flushBuffer();
charOut.flushBuffer();
if(autoFlush)
out.flush();
}
}
catch(InterruptedIOExceptionx){
Thread.currentThread().interrupt();
}
catch(IOExceptionx){
trouble=true;
}
}
//将“boolean数据对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
publicvoidprint(booleanb){
write(b?"true":"false");
}
//将“字符c对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
publicvoidprint(charc){
write(String.valueOf(c));
}
//将“int数据i对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
publicvoidprint(inti){
write(String.valueOf(i));
}
//将“long型数据l对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
publicvoidprint(longl){
write(String.valueOf(l));
}
//将“float数据f对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
publicvoidprint(floatf){
write(String.valueOf(f));
}
//将“double数据d对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
publicvoidprint(doubled){
write(String.valueOf(d));
}
//将“字符数组s”写入到“PrintStream输出流”中，print实际调用的是write函数
publicvoidprint(chars[]){
write(s);
}
//将“字符串数据s”写入到“PrintStream输出流”中，print实际调用的是write函数
publicvoidprint(Strings){
if(s==null){
s="null";
}
write(s);
}
//将“对象obj对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数
publicvoidprint(Objectobj){
write(String.valueOf(obj));
}
//将“换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
publicvoidprintln(){
newLine();
}
//将“boolean数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
publicvoidprintln(booleanx){
synchronized(this){
print(x);
newLine();
}
}
//将“字符x对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
publicvoidprintln(charx){
synchronized(this){
print(x);
newLine();
}
}
//将“int数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
publicvoidprintln(intx){
synchronized(this){
print(x);
newLine();
}
}
//将“long数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
publicvoidprintln(longx){
synchronized(this){
print(x);
newLine();
}
}
//将“float数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
publicvoidprintln(floatx){
synchronized(this){
print(x);
newLine();
}
}
//将“double数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
publicvoidprintln(doublex){
synchronized(this){
print(x);
newLine();
}
}
//将“字符数组x+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
publicvoidprintln(charx[]){
synchronized(this){
print(x);
newLine();
}
}
//将“字符串x+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
publicvoidprintln(Stringx){
synchronized(this){
print(x);
newLine();
}
}
//将“对象o对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数
publicvoidprintln(Objectx){
Strings=String.valueOf(x);
synchronized(this){
print(s);
newLine();
}
}
//将“数据args”根据“默认Locale值(区域属性)”按照format格式化，并写入到“PrintStream输出流”中
publicPrintStreamprintf(Stringformat,Object...args){
returnformat(format,args);
}
//将“数据args”根据“Locale值(区域属性)”按照format格式化，并写入到“PrintStream输出流”中
publicPrintStreamprintf(Localel,Stringformat,Object...args){
returnformat(l,format,args);
}
//根据“默认的Locale值(区域属性)”来格式化数据
publicPrintStreamformat(Stringformat,Object...args){
try{
synchronized(this){
ensureOpen();
if((formatter==null)
||(formatter.locale()!=Locale.getDefault()))
formatter=newFormatter((Appendable)this);
formatter.format(Locale.getDefault(),format,args);
}
}catch(InterruptedIOExceptionx){
Thread.currentThread().interrupt();
}catch(IOExceptionx){
trouble=true;
}
returnthis;
}
//根据“Locale值(区域属性)”来格式化数据
publicPrintStreamformat(Localel,Stringformat,Object...args){
try{
synchronized(this){
ensureOpen();
if((formatter==null)
||(formatter.locale()!=l))
formatter=newFormatter(this,l);
formatter.format(l,format,args);
}
}catch(InterruptedIOExceptionx){
Thread.currentThread().interrupt();
}catch(IOExceptionx){
trouble=true;
}
returnthis;
}
//将“字符序列的全部字符”追加到“PrintStream输出流中”
publicPrintStreamappend(CharSequencecsq){
if(csq==null)
print("null");
else
print(csq.toString());
returnthis;
}
//将“字符序列从start(包括)到end(不包括)的全部字符”追加到“PrintStream输出流中”
publicPrintStreamappend(CharSequencecsq,intstart,intend){
CharSequencecs=(csq==null?"null":csq);
write(cs.subSequence(start,end).toString());
returnthis;
}
//将“字符c”追加到“PrintStream输出流中”
publicPrintStreamappend(charc){
print(c);
returnthis;
}
}

说明：

PrintStream的源码比较简单，请上文的注释进行阅读。若有不明白的地方，建议先看看后面的PrintStream使用示例；待搞清它的作用和用法之后，再来阅读源码。

PrintStream和DataOutputStream异同点

相同点：都是继承与FileOutputStream，用于包装其它输出流。

不同点：

(01)PrintStream和DataOutputStream都可以将数据格式化输出；但它们在“输出字符串”时的编码不同。

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

(02)它们的写入数据时的异常处理机制不同。

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

而PrintStream在通过write()向“输出流”中写入数据时，若产生IOException，则会在write()中进行捕获处理；并设置trouble标记(用于表示产生了异常)为true。用户可以通过checkError()返回trouble值，从而检查输出流中是否产生了异常。

(03)构造函数不同

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

而PrintStream的构造函数有许多：和DataOutputStream一样，支持以输出流out作为“PrintStream输出流”的构造函数；还支持以“File对象”或者“String类型的文件名对象”的构造函数。
而且，在PrintStream的构造函数中，能“指定字符集”和“是否支持自动flush()操作”。

(04)目的不同

DataOutputStream的作用是装饰其它的输出流，它和DataInputStream配合使用：允许应用程序以与机器无关的方式从底层输入流中读写java数据类型。

而PrintStream的作用虽然也是装饰其他输出流，但是它的目的不是以与机器无关的方式从底层读写java数据类型；而是为其它输出流提供打印各种数据值表示形式，使其它输出流能方便的通过print(),println()或printf()等输出各种格式的数据。

示例代码

关于PrintStream中API的详细用法，参考示例代码(PrintStreamTest.java)：

importjava.io.PrintStream;
importjava.io.File;
importjava.io.FileOutputStream;
importjava.io.IOException;
/**
*PrintStream的示例程序
*
*
*/
publicclassPrintStreamTest{
publicstaticvoidmain(String[]args){
//下面3个函数的作用都是一样：都是将字母“abcde”写入到文件“file.txt”中。
//任选一个执行即可！
testPrintStreamConstrutor();
//testPrintStreamConstrutor2();
//testPrintStreamConstrutor3();
//测试write(),print(),println(),printf()等接口。
testPrintStreamAPIS();
}
/**
*PrintStream(OutputStreamout)的测试函数
*
*函数的作用，就是将字母“abcde”写入到文件“file.txt”中
*/
privatestaticvoidtestPrintStreamConstrutor(){
//0x61对应ASCII码的字母'a'，0x62对应ASCII码的字母'b',...
finalbyte[]arr={0x61,0x62,0x63,0x64,0x65};//abced
try{
//创建文件“file.txt”的File对象
Filefile=newFile("file.txt");
//创建文件对应FileOutputStream
PrintStreamout=newPrintStream(
newFileOutputStream(file));
//将“字节数组arr”全部写入到输出流中
out.write(arr);
//关闭输出流
out.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
/**
*PrintStream(Filefile)的测试函数
*
*函数的作用，就是将字母“abcde”写入到文件“file.txt”中
*/
privatestaticvoidtestPrintStreamConstrutor2(){
finalbyte[]arr={0x61,0x62,0x63,0x64,0x65};
try{
Filefile=newFile("file.txt");
PrintStreamout=newPrintStream(file);
out.write(arr);
out.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
/**
*PrintStream(StringfileName)的测试函数
*
*函数的作用，就是将字母“abcde”写入到文件“file.txt”中
*/
privatestaticvoidtestPrintStreamConstrutor3(){
finalbyte[]arr={0x61,0x62,0x63,0x64,0x65};
try{
PrintStreamout=newPrintStream("file.txt");
out.write(arr);
out.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
/**
*测试write(),print(),println(),printf()等接口。
*/
privatestaticvoidtestPrintStreamAPIS(){
//0x61对应ASCII码的字母'a'，0x62对应ASCII码的字母'b',...
finalbyte[]arr={0x61,0x62,0x63,0x64,0x65};//abced
try{
//创建文件对应FileOutputStream
PrintStreamout=newPrintStream("other.txt");
//将字符串“helloPrintStream”+回车符，写入到输出流中
out.println("helloPrintStream");
//将x写入到输出流中
//x对应ASCII码的字母'A'，也就是写入字符'A'
out.write(0x41);
//将字符串"65"写入到输出流中。
//out.print(0x41);等价于out.write(String.valueOf(0x41));
out.print(0x41);
//将字符'B'追加到输出流中
out.append('B');
//将"CDEis5"+回车写入到输出流中
Stringstr="CDE";
intnum=5;
out.printf("%sis%d\n",str,num);
out.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}

运行上面的代码，会在源码所在目录生成两个文件“file.txt”和“other.txt”。

file.txt的内容如下：

abcde

other.txt的内容如下：

helloPrintStream
A65BCDEis5

以上所述是小编给大家介绍的Java中的Printstream知识，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对毛票票网站的支持

Java 中的Printstream介绍_动力节点Java学院整理

热门推荐

随机推荐