skywang12345

导航

统计
 

更多内容请参考:java io系列01之 "目录" 

PrintWriter 介绍

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

 

PrintWriter 函数列表

PrintWriter(OutputStream out)
PrintWriter(OutputStream out, boolean autoFlush)
PrintWriter(Writer wr)
PrintWriter(Writer wr, boolean autoFlush)
PrintWriter(File file)
PrintWriter(File file, String csn)
PrintWriter(String fileName)
PrintWriter(String fileName, String csn)

PrintWriter     append(char c)
PrintWriter     append(CharSequence csq, int start, int end)
PrintWriter     append(CharSequence csq)
boolean     checkError()
void     close()
void     flush()
PrintWriter     format(Locale l, String format, Object... args)
PrintWriter     format(String format, Object... args)
void     print(float fnum)
void     print(double dnum)
void     print(String str)
void     print(Object obj)
void     print(char ch)
void     print(char[] charArray)
void     print(long lnum)
void     print(int inum)
void     print(boolean bool)
PrintWriter     printf(Locale l, String format, Object... args)
PrintWriter     printf(String format, Object... args)
void     println()
void     println(float f)
void     println(int i)
void     println(long l)
void     println(Object obj)
void     println(char[] chars)
void     println(String str)
void     println(char c)
void     println(double d)
void     println(boolean b)
void     write(char[] buf, int offset, int count)
void     write(int oneChar)
void     write(char[] buf)
void     write(String str, int offset, int count)
void     write(String str)

 

PrintWriter 源码

  1 package java.io;
  2 
  3 import java.util.Objects;
  4 import java.util.Formatter;
  5 import java.util.Locale;
  6 import java.nio.charset.Charset;
  7 import java.nio.charset.IllegalCharsetNameException;
  8 import java.nio.charset.UnsupportedCharsetException;
  9 
 10 public class PrintWriter extends Writer {
 11 
 12     protected Writer out;
 13 
 14     // 自动flush
 15     // 所谓“自动flush”,就是每次执行print(), println(), write()函数,都会调用flush()函数;
 16     // 而“不自动flush”,则需要我们手动调用flush()接口。
 17     private final boolean autoFlush;
 18     // PrintWriter是否右产生异常。当PrintWriter有异常产生时,会被本身捕获,并设置trouble为true
 19     private boolean trouble = false;
 20     // 用于格式化的对象
 21     private Formatter formatter;
 22     private PrintStream psOut = null;
 23 
 24     // 行分割符
 25     private final String lineSeparator;
 26 
 27     // 获取csn(字符集名字)对应的Chaset
 28     private static Charset toCharset(String csn)
 29         throws UnsupportedEncodingException
 30     {
 31         Objects.requireNonNull(csn, "charsetName");
 32         try {
 33             return Charset.forName(csn);
 34         } catch (IllegalCharsetNameException|UnsupportedCharsetException unused) {
 35             // UnsupportedEncodingException should be thrown
 36             throw new UnsupportedEncodingException(csn);
 37         }
 38     }
 39 
 40     // 将“Writer对象out”作为PrintWriter的输出流,默认不会自动flush,并且采用默认字符集。
 41     public PrintWriter (Writer out) {
 42         this(out, false);
 43     }
 44 
 45     // 将“Writer对象out”作为PrintWriter的输出流,autoFlush的flush模式,并且采用默认字符集。
 46     public PrintWriter(Writer out, boolean autoFlush) {
 47         super(out);
 48         this.out = out;
 49         this.autoFlush = autoFlush;
 50         lineSeparator = java.security.AccessController.doPrivileged(
 51             new sun.security.action.GetPropertyAction("line.separator"));
 52     }
 53 
 54     // 将“输出流对象out”作为PrintWriter的输出流,不自动flush,并且采用默认字符集。
 55     public PrintWriter(OutputStream out) {
 56         this(out, false);
 57     }
 58 
 59     // 将“输出流对象out”作为PrintWriter的输出流,autoFlush的flush模式,并且采用默认字符集。
 60     public PrintWriter(OutputStream out, boolean autoFlush) {
 61         // new OutputStreamWriter(out):将“字节类型的输出流”转换为“字符类型的输出流”
 62         // new BufferedWriter(...): 为输出流提供缓冲功能。
 63         this(new BufferedWriter(new OutputStreamWriter(out)), autoFlush);
 64 
 65         // save print stream for error propagation
 66         if (out instanceof java.io.PrintStream) {
 67             psOut = (PrintStream) out;
 68         }
 69     }
 70 
 71     // 创建fileName对应的OutputStreamWriter,进而创建BufferedWriter对象;然后将该BufferedWriter作为PrintWriter的输出流,不自动flush,采用默认字符集。
 72     public PrintWriter(String fileName) throws FileNotFoundException {
 73         this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName))),
 74              false);
 75     }
 76 
 77     // 创建fileName对应的OutputStreamWriter,进而创建BufferedWriter对象;然后将该BufferedWriter作为PrintWriter的输出流,不自动flush,采用字符集charset。
 78     private PrintWriter(Charset charset, File file)
 79         throws FileNotFoundException
 80     {
 81         this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), charset)),
 82              false);
 83     }
 84 
 85     // 创建fileName对应的OutputStreamWriter,进而创建BufferedWriter对象;然后将该BufferedWriter作为PrintWriter的输出流,不自动flush,采用csn字符集。
 86     public PrintWriter(String fileName, String csn)
 87         throws FileNotFoundException, UnsupportedEncodingException
 88     {
 89         this(toCharset(csn), new File(fileName));
 90     }
 91 
 92     // 创建file对应的OutputStreamWriter,进而创建BufferedWriter对象;然后将该BufferedWriter作为PrintWriter的输出流,不自动flush,采用默认字符集。
 93     public PrintWriter(File file) throws FileNotFoundException {
 94         this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file))),
 95              false);
 96     }
 97 
 98     // 创建file对应的OutputStreamWriter,进而创建BufferedWriter对象;然后将该BufferedWriter作为PrintWriter的输出流,不自动flush,采用csn字符集。
 99     public PrintWriter(File file, String csn)
100         throws FileNotFoundException, UnsupportedEncodingException
101     {
102         this(toCharset(csn), file);
103     }
104 
105     private void ensureOpen() throws IOException {
106         if (out == null)
107             throw new IOException("Stream closed");
108     }
109 
110     // flush“PrintWriter输出流中的数据”。
111     public void flush() {
112         try {
113             synchronized (lock) {
114                 ensureOpen();
115                 out.flush();
116             }
117         }
118         catch (IOException x) {
119             trouble = true;
120         }
121     }
122 
123     public void close() {
124         try {
125             synchronized (lock) {
126                 if (out == null)
127                     return;
128                 out.close();
129                 out = null;
130             }
131         }
132         catch (IOException x) {
133             trouble = true;
134         }
135     }
136 
137     // flush“PrintWriter输出流缓冲中的数据”,并检查错误
138     public boolean checkError() {
139         if (out != null) {
140             flush();
141         }
142         if (out instanceof java.io.PrintWriter) {
143             PrintWriter pw = (PrintWriter) out;
144             return pw.checkError();
145         } else if (psOut != null) {
146             return psOut.checkError();
147         }
148         return trouble;
149     }
150 
151     protected void setError() {
152         trouble = true;
153     }
154 
155     protected void clearError() {
156         trouble = false;
157     }
158 
159     // 将字符c写入到“PrintWriter输出流”中。c虽然是int类型,但实际只会写入一个字符
160     public void write(int c) {
161         try {
162             synchronized (lock) {
163                 ensureOpen();
164                 out.write(c);
165             }
166         }
167         catch (InterruptedIOException x) {
168             Thread.currentThread().interrupt();
169         }
170         catch (IOException x) {
171             trouble = true;
172         }
173     }
174 
175     // 将“buf中从off开始的len个字符”写入到“PrintWriter输出流”中。
176     public void write(char buf[], int off, int len) {
177         try {
178             synchronized (lock) {
179                 ensureOpen();
180                 out.write(buf, off, len);
181             }
182         }
183         catch (InterruptedIOException x) {
184             Thread.currentThread().interrupt();
185         }
186         catch (IOException x) {
187             trouble = true;
188         }
189     }
190 
191     // 将“buf中的全部数据”写入到“PrintWriter输出流”中。
192     public void write(char buf[]) {
193         write(buf, 0, buf.length);
194     }
195 
196     // 将“字符串s中从off开始的len个字符”写入到“PrintWriter输出流”中。
197     public void write(String s, int off, int len) {
198         try {
199             synchronized (lock) {
200                 ensureOpen();
201                 out.write(s, off, len);
202             }
203         }
204         catch (InterruptedIOException x) {
205             Thread.currentThread().interrupt();
206         }
207         catch (IOException x) {
208             trouble = true;
209         }
210     }
211 
212     // 将“字符串s”写入到“PrintWriter输出流”中。
213     public void write(String s) {
214         write(s, 0, s.length());
215     }
216 
217     // 将“换行符”写入到“PrintWriter输出流”中。
218     private void newLine() {
219         try {
220             synchronized (lock) {
221                 ensureOpen();
222                 out.write(lineSeparator);
223                 if (autoFlush)
224                     out.flush();
225             }
226         }
227         catch (InterruptedIOException x) {
228             Thread.currentThread().interrupt();
229         }
230         catch (IOException x) {
231             trouble = true;
232         }
233     }
234 
235     // 将“boolean数据对应的字符串”写入到“PrintWriter输出流”中,print实际调用的是write函数
236     public void print(boolean b) {
237         write(b ? "true" : "false");
238     }
239 
240     // 将“字符c对应的字符串”写入到“PrintWriter输出流”中,print实际调用的是write函数
241     public void print(char c) {
242         write(c);
243     }
244 
245     // 将“int数据i对应的字符串”写入到“PrintWriter输出流”中,print实际调用的是write函数
246     public void print(int i) {
247         write(String.valueOf(i));
248     }
249 
250     // 将“long型数据l对应的字符串”写入到“PrintWriter输出流”中,print实际调用的是write函数
251     public void print(long l) {
252         write(String.valueOf(l));
253     }
254 
255     // 将“float数据f对应的字符串”写入到“PrintWriter输出流”中,print实际调用的是write函数
256     public void print(float f) {
257         write(String.valueOf(f));
258     }
259 
260     // 将“double数据d对应的字符串”写入到“PrintWriter输出流”中,print实际调用的是write函数
261     public void print(double d) {
262         write(String.valueOf(d));
263     }
264 
265     // 将“字符数组s”写入到“PrintWriter输出流”中,print实际调用的是write函数
266     public void print(char s[]) {
267         write(s);
268     }
269 
270     // 将“字符串数据s”写入到“PrintWriter输出流”中,print实际调用的是write函数
271     public void print(String s) {
272         if (s == null) {
273             s = "null";
274         }
275         write(s);
276     }
277 
278     // 将“对象obj对应的字符串”写入到“PrintWriter输出流”中,print实际调用的是write函数
279     public void print(Object obj) {
280         write(String.valueOf(obj));
281     }
282 
283     // 将“换行符”写入到“PrintWriter输出流”中,println实际调用的是write函数
284     public void println() {
285         newLine();
286     }
287 
288     // 将“boolean数据对应的字符串+换行符”写入到“PrintWriter输出流”中,println实际调用的是write函数
289     public void println(boolean x) {
290         synchronized (lock) {
291             print(x);
292             println();
293         }
294     }
295 
296     // 将“字符x对应的字符串+换行符”写入到“PrintWriter输出流”中,println实际调用的是write函数
297     public void println(char x) {
298         synchronized (lock) {
299             print(x);
300             println();
301         }
302     }
303 
304     // 将“int数据对应的字符串+换行符”写入到“PrintWriter输出流”中,println实际调用的是write函数
305     public void println(int x) {
306         synchronized (lock) {
307             print(x);
308             println();
309         }
310     }
311 
312     // 将“long数据对应的字符串+换行符”写入到“PrintWriter输出流”中,println实际调用的是write函数
313     public void println(long x) {
314         synchronized (lock) {
315             print(x);
316             println();
317         }
318     }
319 
320     // 将“float数据对应的字符串+换行符”写入到“PrintWriter输出流”中,println实际调用的是write函数
321     public void println(float x) {
322         synchronized (lock) {
323             print(x);
324             println();
325         }
326     }
327 
328     // 将“double数据对应的字符串+换行符”写入到“PrintWriter输出流”中,println实际调用的是write函数
329     public void println(double x) {
330         synchronized (lock) {
331             print(x);
332             println();
333         }
334     }
335 
336     // 将“字符数组x+换行符”写入到“PrintWriter输出流”中,println实际调用的是write函数
337     public void println(char x[]) {
338         synchronized (lock) {
339             print(x);
340             println();
341         }
342     }
343 
344     // 将“字符串x+换行符”写入到“PrintWriter输出流”中,println实际调用的是write函数
345     public void println(String x) {
346         synchronized (lock) {
347             print(x);
348             println();
349         }
350     }
351 
352     // 将“对象o对应的字符串+换行符”写入到“PrintWriter输出流”中,println实际调用的是write函数
353     public void println(Object x) {
354         String s = String.valueOf(x);
355         synchronized (lock) {
356             print(s);
357             println();
358         }
359     }
360 
361     // 将“数据args”根据“默认Locale值(区域属性)”按照format格式化,并写入到“PrintWriter输出流”中
362     public PrintWriter printf(String format, Object ... args) {
363         return format(format, args);
364     }
365 
366     // 将“数据args”根据“Locale值(区域属性)”按照format格式化,并写入到“PrintWriter输出流”中
367     public PrintWriter printf(Locale l, String format, Object ... args) {
368         return format(l, format, args);
369     }
370 
371     // 根据“默认的Locale值(区域属性)”来格式化数据
372     public PrintWriter format(String format, Object ... args) {
373         try {
374             synchronized (lock) {
375                 ensureOpen();
376                 if ((formatter == null)
377                     || (formatter.locale() != Locale.getDefault()))
378                     formatter = new Formatter(this);
379                 formatter.format(Locale.getDefault(), format, args);
380                 if (autoFlush)
381                     out.flush();
382             }
383         } catch (InterruptedIOException x) {
384             Thread.currentThread().interrupt();
385         } catch (IOException x) {
386             trouble = true;
387         }
388         return this;
389     }
390 
391     // 根据“Locale值(区域属性)”来格式化数据
392     public PrintWriter format(Locale l, String format, Object ... args) {
393         try {
394             synchronized (lock) {
395                 ensureOpen();
396                 if ((formatter == null) || (formatter.locale() != l))
397                     formatter = new Formatter(this, l);
398                 formatter.format(l, format, args);
399                 if (autoFlush)
400                     out.flush();
401             }
402         } catch (InterruptedIOException x) {
403             Thread.currentThread().interrupt();
404         } catch (IOException x) {
405             trouble = true;
406         }
407         return this;
408     }
409 
410     // 将“字符序列的全部字符”追加到“PrintWriter输出流中”
411     public PrintWriter append(CharSequence csq) {
412         if (csq == null)
413             write("null");
414         else
415             write(csq.toString());
416         return this;
417     }
418 
419     // 将“字符序列从start(包括)到end(不包括)的全部字符”追加到“PrintWriter输出流中”
420     public PrintWriter append(CharSequence csq, int start, int end) {
421         CharSequence cs = (csq == null ? "null" : csq);
422         write(cs.subSequence(start, end).toString());
423         return this;
424     }
425 
426     // 将“字符c”追加到“PrintWriter输出流中”
427     public PrintWriter append(char c) {
428         write(c);
429         return this;
430     }
431 }
View Code

 

示例代码

关于PrintWriter中API的详细用法,参考示例代码(PrintWriterTest.java):

  1 import java.io.PrintWriter;
  2 import java.io.File;
  3 import java.io.FileOutputStream;
  4 import java.io.IOException;
  5 
  6 /**
  7  * PrintWriter 的示例程序
  8  *
  9  * @author skywang
 10  */
 11 public class PrintWriterTest {
 12 
 13     public static void main(String[] args) {
 14 
 15         // 下面3个函数的作用都是一样:都是将字母“abcde”写入到文件“file.txt”中。
 16         // 任选一个执行即可!
 17         testPrintWriterConstrutor1() ;
 18         //testPrintWriterConstrutor2() ;
 19         //testPrintWriterConstrutor3() ;
 20 
 21         // 测试write(), print(), println(), printf()等接口。
 22         testPrintWriterAPIS() ;
 23     }
 24 
 25     /**
 26      * PrintWriter(OutputStream out) 的测试函数
 27      *
 28      * 函数的作用,就是将字母“abcde”写入到文件“file.txt”中
 29      */
 30     private static void testPrintWriterConstrutor1() {
 31         final char[] arr={'a', 'b', 'c', 'd', 'e' };
 32         try {
 33             // 创建文件“file.txt”的File对象
 34             File file = new File("file.txt");
 35             // 创建文件对应FileOutputStream
 36             PrintWriter out = new PrintWriter(
 37                     new FileOutputStream(file));
 38             // 将“字节数组arr”全部写入到输出流中
 39             out.write(arr);
 40             // 关闭输出流
 41             out.close();
 42         } catch (IOException e) {
 43             e.printStackTrace();
 44         }
 45     }
 46 
 47     /**
 48      * PrintWriter(File file) 的测试函数
 49      *
 50      * 函数的作用,就是将字母“abcde”写入到文件“file.txt”中
 51      */
 52     private static void testPrintWriterConstrutor2() {
 53         final char[] arr={'a', 'b', 'c', 'd', 'e' };
 54         try {
 55             File file = new File("file.txt");
 56             PrintWriter out = new PrintWriter(file);
 57             out.write(arr);
 58             out.close();
 59         } catch (IOException e) {
 60             e.printStackTrace();
 61         }
 62     }
 63 
 64     /**
 65      * PrintWriter(String fileName) 的测试函数
 66      *
 67      * 函数的作用,就是将字母“abcde”写入到文件“file.txt”中
 68      */
 69     private static void testPrintWriterConstrutor3() {
 70         final char[] arr={'a', 'b', 'c', 'd', 'e' };
 71         try {
 72             PrintWriter out = new PrintWriter("file.txt");
 73             out.write(arr);
 74             out.close();
 75         } catch (IOException e) {
 76             e.printStackTrace();
 77         }
 78     }
 79 
 80     /**
 81      * 测试write(), print(), println(), printf()等接口。
 82      */
 83     private static void testPrintWriterAPIS() {
 84         final char[] arr={'a', 'b', 'c', 'd', 'e' };
 85         try {
 86             // 创建文件对应FileOutputStream
 87             PrintWriter out = new PrintWriter("other.txt");
 88 
 89             // 将字符串“hello PrintWriter”+回车符,写入到输出流中
 90             out.println("hello PrintWriter");
 91             // 将0x41写入到输出流中
 92             // 0x41对应ASCII码的字母'A',也就是写入字符'A'
 93             out.write(0x41);
 94             // 将字符串"65"写入到输出流中。
 95             // out.print(0x41); 等价于 out.write(String.valueOf(0x41));
 96             out.print(0x41);
 97             // 将字符'B'追加到输出流中
 98             out.append('B').append("CDEF");
 99 
100             // 将"CDE is 5" + 回车  写入到输出流中
101             String str = "GHI";
102             int num = 5;
103             out.printf("%s is %d\n", str, num);
104 
105             out.close();
106         } catch (IOException e) {
107             e.printStackTrace();
108         }
109     }
110 }

运行上面的代码,会在源码所在目录生成两个文件“file.txt”和“other.txt”。
file.txt的内容如下:
abcde
other.txt的内容如下:
hello PrintWriter
A65BCDEFGHI is 5

 

posted on 2013-11-07 21:45  如果天空不死  阅读(...)  评论(...编辑  收藏