PrintStream 介紹
PrintStream 是打印輸出流，它繼承于FilterOutputStream。
PrintStream 是用來裝飾其它輸出流。它能為其他輸出流添加了功能，使它們能夠方便地打印各種數據值表示形式。
與其他輸出流不同，PrintStream 永遠不會拋出 IOException；它產生的IOException會被自身的函數所捕獲并設置錯誤標記， 用戶可以通過 checkError() 返回錯誤標記，從而查看PrintStream內部是否產生了IOException。
另外，PrintStream 提供了自動flush 和 字符集設置功能。所謂自動flush，就是往PrintStream寫入的數據會立刻調用flush()函數。
PrintStream 函數列表
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
|
/* * 構造函數 */// 將“輸出流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) |
注意：print()和println()都是將其中參數轉換成字符串之后，再寫入到輸入流。
例如，
|
1
|
print(0x61); |
等價于
|
1
|
write(String.valueOf(0x61)); |
上面語句是將字符串"97"寫入到輸出流。0x61對應十進制數是97。
|
1
|
write(0x61) |
上面語句是將字符'a'寫入到輸出流。因為0x61對應的ASCII碼的字母'a'。
查看下面的代碼，我們能對這些函數有更清晰的認識！
PrintStream 源碼分析(基于jdk1.7.40)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
|
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 = ; 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') >= )) 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; }} |
說明：
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(OutputStream out)。即它只支持以輸出流out作為“DataOutputStream的輸出流”。
而PrintStream的構造函數有許多：和DataOutputStream一樣，支持以輸出流out作為“PrintStream輸出流”的構造函數；還支持以“File對象”或者“String類型的文件名對象”的構造函數。
而且，在PrintStream的構造函數中，能“指定字符集”和“是否支持自動flush()操作”。
(04) 目的不同
DataOutputStream的作用是裝飾其它的輸出流，它和DataInputStream配合使用：允許應用程序以與機器無關的方式從底層輸入流中讀寫java數據類型。
而PrintStream的作用雖然也是裝飾其他輸出流，但是它的目的不是以與機器無關的方式從底層讀寫java數據類型；而是為其它輸出流提供打印各種數據值表示形式，使其它輸出流能方便的通過print(), println()或printf()等輸出各種格式的數據。
示例代碼
關于PrintStream中API的詳細用法，參考示例代碼(PrintStreamTest.java)：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
import java.io.PrintStream; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; /** * PrintStream 的示例程序 * * */ public class PrintStreamTest { public static void main(String[] args) { // 下面3個函數的作用都是一樣：都是將字母“abcde”寫入到文件“file.txt”中。 // 任選一個執行即可！ testPrintStreamConstrutor() ; //testPrintStreamConstrutor2() ; //testPrintStreamConstrutor3() ; // 測試write(), print(), println(), printf()等接口。 testPrintStreamAPIS() ; } /** * PrintStream(OutputStream out) 的測試函數 * * 函數的作用，就是將字母“abcde”寫入到文件“file.txt”中 */ private static void testPrintStreamConstrutor() { // 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"); // 將x寫入到輸出流中 // x對應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的內容如下：
|
1
2
|
hello PrintStreamA65BCDE is 5 |
以上所述是小編給大家介紹的Java 中的Printstream知識，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對服務器之家網站的支持
