IO流

  1 package io;
  2 
  3 import java.io.BufferedInputStream;
  4 import java.io.BufferedOutputStream;
  5 import java.io.BufferedReader;
  6 import java.io.BufferedWriter;
  7 import java.io.File;
  8 import java.io.FileInputStream;
  9 import java.io.FileOutputStream;
 10 import java.io.FileReader;
 11 import java.io.FileWriter;
 12 import java.io.IOException;
 13 import java.io.InputStream;
 14 import java.io.OutputStream;
 15 import java.io.Reader;
 16 import java.io.Writer;
 17 
 18 public class test {
 19 
 20     public static void main(String[] args) {
 21 
 22         // testFileOutputStream();
 23 
 24         System.out.println("**********这是一个分隔符**********");
 25 
 26         // testFileInputStream();
 27 
 28         System.out.println("**********这是一个分隔符**********");
 29 
 30         // testBufferedOutputStream();
 31 
 32         System.out.println("**********这是一个分隔符**********");
 33 
 34         // testBufferedInputStream();
 35 
 36         System.out.println("**********这是一个分隔符**********");
 37 
 38         // testFileWriter();
 39 
 40         System.out.println("**********这是一个分隔符**********");
 41 
 42         // testFileWriterAppend();
 43 
 44         System.out.println("**********这是一个分隔符**********");
 45 
 46         // testFileReader();
 47 
 48         System.out.println("**********这是一个分隔符**********");
 49 
 50         // testBufferedWriter();
 51 
 52         System.out.println("**********这是一个分隔符**********");
 53 
 54         // testBufferedWriterNewLineAppend();
 55 
 56         System.out.println("**********这是一个分隔符**********");
 57 
 58         // testBufferedWriterAppend();
 59 
 60         System.out.println("**********这是一个分隔符**********");
 61 
 62         // testBufferedReader();
 63 
 64         System.out.println("**********这是一个分隔符**********");
 65 
 66         // testBufferedReaderReadLine();
 67 
 68     }
 69 
 70     /**
 71      * 缓冲输入字符流
 72      */
 73     private static void testBufferedReaderReadLine() {
 74 
 75         Reader r = null;
 76         BufferedReader br = null;
 77 
 78         try {
 79 
 80             File f = new File("D:\\IO\\testBufferedReader.txt");
 81 
 82             r = new FileReader(f);
 83             br = new BufferedReader(r);
 84 
 85             String temp;
 86 
 87             while ((temp = br.readLine()) != null) {
 88 
 89                 System.out.println(temp);// 每次读取一行，为字符串，字符串为null时，文件内容读取完毕
 90 
 91             }
 92 
 93         } catch (IOException e) {
 94             System.out.println("IO异常，失败");
 95             e.printStackTrace();
 96         } finally {
 97 
 98             try {
 99 
100                 br.close();
101                 r.close();
102 
103             } catch (IOException e) {
104                 System.out.println("IO异常，失败");
105                 e.printStackTrace();
106             }
107 
108         }
109 
110     }
111 
112     /**
113      * 缓冲输入字符流
114      */
115     private static void testBufferedReader() {
116 
117         Reader r = null;
118         BufferedReader br = null;
119 
120         try {
121 
122             File f = new File("D:\\IO\\testBufferedReader.txt");
123 
124             r = new FileReader(f);
125             br = new BufferedReader(r);
126 
127             int temp;
128             String str = "";
129 
130             while ((temp = br.read()) != -1) {
131 
132                 str += (char) temp;// 每次读一个字符的ASCII码，转换为字符，添加为字符串，读取ASCII码为-1时，文件内容读取完毕
133 
134             }
135 
136             System.out.println(str);
137 
138         } catch (IOException e) {
139             System.out.println("IO异常，失败");
140             e.printStackTrace();
141         } finally {
142 
143             try {
144 
145                 br.close();
146                 r.close();
147 
148             } catch (IOException e) {
149                 System.out.println("IO异常，失败");
150                 e.printStackTrace();
151             }
152 
153         }
154 
155     }
156 
157     /**
158      * 缓冲输出字符流
159      */
160     private static void testBufferedWriterAppend() {
161 
162         Writer w = null;
163         BufferedWriter bw = null;
164 
165         try {
166 
167             File f = new File("D:\\IO\\testBufferedWriter.txt");
168 
169             w = new FileWriter(f, true);// 将新的字符串添加到文件内容末尾
170             bw = new BufferedWriter(w);
171 
172             bw.write("新增加一行\r\n");
173 
174             bw.flush();// 将缓冲区的数据全部刷新到文件中，使用缓冲区时使用
175 
176             System.out.println("完成");
177 
178         } catch (IOException e) {
179             System.out.println("IO异常，失败");
180             e.printStackTrace();
181         } finally {
182 
183             try {
184 
185                 bw.close();
186                 w.close();
187 
188             } catch (IOException e) {
189                 System.out.println("IO异常，失败");
190                 e.printStackTrace();
191             }
192 
193         }
194 
195     }
196 
197     /**
198      * 缓冲输出字符流
199      */
200     private static void testBufferedWriterNewLineAppend() {
201 
202         Writer w = null;
203         BufferedWriter bw = null;
204 
205         try {
206 
207             String str = "我在等你，等下完这场雨\r\n" + "满城涓涤，净此生的别离\r\n" + "心太入戏，梦流转四季只是回忆\r\n" + "手中焰火向谁泣\r\n"
208                     + "如果可以，别下完这场雨\r\n" + "放慢朝夕，拾与你的点滴\r\n" + "怕来不及，回眸再重温此刻如往昔\r\n" + "伞外朦胧可是你\r\n";// "\r\n"是Windows系统的换行
209 
210             File f = new File("D:\\IO\\testBufferedWriter.txt");
211 
212             w = new FileWriter(f);
213             bw = new BufferedWriter(w);
214 
215             bw.write(str);
216 
217             bw.newLine();// 适应计算机系统的换行
218             bw.append("新增加一行\r\n");
219 
220             bw.flush();// 将缓冲区的数据全部刷新到文件中，使用缓冲区时使用
221 
222             System.out.println("完成");
223 
224         } catch (IOException e) {
225             System.out.println("IO异常，失败");
226             e.printStackTrace();
227         } finally {
228 
229             try {
230 
231                 bw.close();
232                 w.close();
233 
234             } catch (IOException e) {
235                 System.out.println("IO异常，失败");
236                 e.printStackTrace();
237             }
238 
239         }
240 
241     }
242 
243     /**
244      * 缓冲输出字符流
245      */
246     private static void testBufferedWriter() {
247 
248         Writer w = null;
249         BufferedWriter bw = null;
250 
251         try {
252 
253             String str = "我在等你，等下完这场雨\r\n" + "满城涓涤，净此生的别离\r\n" + "心太入戏，梦流转四季只是回忆\r\n" + "手中焰火向谁泣\r\n"
254                     + "如果可以，别下完这场雨\r\n" + "放慢朝夕，拾与你的点滴\r\n" + "怕来不及，回眸再重温此刻如往昔\r\n" + "伞外朦胧可是你\r\n";// "\r\n"是Windows系统的换行
255 
256             File f = new File("D:\\IO\\testBufferedWriter.txt");
257 
258             w = new FileWriter(f);
259             bw = new BufferedWriter(w);
260 
261             bw.write(str);
262 
263             bw.flush();// 将缓冲区的数据全部刷新到文件中，使用缓冲区时使用
264 
265             System.out.println("完成");
266 
267         } catch (IOException e) {
268             System.out.println("IO异常，失败");
269             e.printStackTrace();
270         } finally {
271 
272             try {
273 
274                 bw.close();
275                 w.close();
276 
277             } catch (IOException e) {
278                 System.out.println("IO异常，失败");
279                 e.printStackTrace();
280             }
281 
282         }
283 
284     }
285 
286     /**
287      * 文件输入字符流
288      */
289     private static void testFileReader() {
290 
291         Reader r = null;
292 
293         try {
294 
295             File f = new File("D:\\IO\\testFileReader.txt");
296 
297             r = new FileReader(f);
298 
299             int temp;
300             String str = "";
301 
302             while ((temp = r.read()) != -1) {
303 
304                 str += (char) temp;// 每次读一个字符的ASCII码，转换为字符，添加为字符串，读取ASCII码为-1时，文件内容读取完毕
305 
306             }
307 
308             System.out.println(str);
309 
310         } catch (IOException e) {
311             System.out.println("IO异常，失败");
312             e.printStackTrace();
313         } finally {
314 
315             try {
316 
317                 r.close();
318 
319             } catch (IOException e) {
320                 System.out.println("IO异常，失败");
321                 e.printStackTrace();
322             }
323 
324         }
325 
326     }
327 
328     /**
329      * 文件输出字符流
330      */
331     private static void testFileWriterAppend() {
332 
333         Writer w = null;
334 
335         try {
336 
337             File f = new File("D:\\IO\\testFileWriter.txt");
338 
339             w = new FileWriter(f, true);// 将新的字符串添加到文件内容末尾
340 
341             w.write("新增加一行\r\n");
342 
343             w.flush();// 将缓冲区的数据全部刷新到文件中，使用缓冲区时使用
344 
345             System.out.println("完成");
346 
347         } catch (IOException e) {
348             System.out.println("IO异常，失败");
349             e.printStackTrace();
350         } finally {
351 
352             try {
353 
354                 w.close();
355 
356             } catch (IOException e) {
357                 System.out.println("IO异常，失败");
358                 e.printStackTrace();
359             }
360 
361         }
362 
363     }
364 
365     /**
366      * 文件输出字符流
367      */
368     private static void testFileWriter() {
369 
370         Writer w = null;
371 
372         try {
373 
374             String str = "我在等你，等下完这场雨\r\n" + "满城涓涤，净此生的别离\r\n" + "心太入戏，梦流转四季只是回忆\r\n" + "手中焰火向谁泣\r\n"
375                     + "如果可以，别下完这场雨\r\n" + "放慢朝夕，拾与你的点滴\r\n" + "怕来不及，回眸再重温此刻如往昔\r\n" + "伞外朦胧可是你\r\n";// "\r\n"是Windows系统的换行
376 
377             File f = new File("D:\\IO\\testFileWriter.txt");
378 
379             w = new FileWriter(f);
380 
381             w.write(str);
382 
383             w.flush();// 将缓冲区的数据全部刷新到文件中，使用缓冲区时使用
384 
385             System.out.println("完成");
386 
387         } catch (IOException e) {
388             System.out.println("IO异常，失败");
389             e.printStackTrace();
390         } finally {
391 
392             try {
393 
394                 w.close();
395 
396             } catch (IOException e) {
397                 System.out.println("IO异常，失败");
398                 e.printStackTrace();
399             }
400 
401         }
402 
403     }
404 
405     /**
406      * 缓冲输入字节流
407      */
408     private static void testBufferedInputStream() {
409 
410         InputStream is = null;
411         BufferedInputStream bis = null;
412 
413         try {
414 
415             File f = new File("D:\\IO\\testBufferedInputStream.txt");
416 
417             is = new FileInputStream(f);
418             bis = new BufferedInputStream(is);
419 
420             byte[] b = new byte[(int) f.length()];// 获取文件的字节长度
421 
422             bis.read(b);
423 
424             System.out.println(new String(b));// 转换成字符串输出
425 
426         } catch (IOException e) {
427             System.out.println("IO异常，失败");
428             e.printStackTrace();
429         } finally {
430 
431             try {
432 
433                 bis.close();
434                 is.close();
435 
436             } catch (IOException e) {
437                 System.out.println("IO异常，失败");
438                 e.printStackTrace();
439             }
440 
441         }
442 
443     }
444 
445     /**
446      * 缓冲输出字节流
447      */
448     private static void testBufferedOutputStream() {
449 
450         OutputStream os = null;
451         BufferedOutputStream bos = null;
452 
453         try {
454 
455             String str = "我在等你，等下完这场雨\r\n" + "满城涓涤，净此生的别离\r\n" + "心太入戏，梦流转四季只是回忆\r\n" + "手中焰火向谁泣\r\n"
456                     + "如果可以，别下完这场雨\r\n" + "放慢朝夕，拾与你的点滴\r\n" + "怕来不及，回眸再重温此刻如往昔\r\n" + "伞外朦胧可是你\r\n";// "\r\n"是Windows系统的换行
457 
458             File f = new File("D:\\IO\\testBufferedOutputStream.txt");
459 
460             os = new FileOutputStream(f);
461             bos = new BufferedOutputStream(os);
462 
463             bos.write(str.getBytes());// 获取字节数组
464 
465             bos.flush();// 将缓冲区的数据全部刷新到文件中，使用缓冲区时使用
466 
467             System.out.println("完成");
468 
469         } catch (IOException e) {
470             System.out.println("IO异常，失败");
471             e.printStackTrace();
472         } finally {
473 
474             try {
475 
476                 bos.close();
477                 os.close();
478 
479             } catch (IOException e) {
480                 System.out.println("IO异常，失败");
481                 e.printStackTrace();
482             }
483 
484         }
485 
486     }
487 
488     /**
489      * 文件输入字节流
490      */
491     private static void testFileInputStream() {
492 
493         InputStream is = null;
494 
495         try {
496 
497             File f = new File("D:\\IO\\testFileInputStream.txt");
498 
499             is = new FileInputStream(f);
500 
501             byte[] b = new byte[(int) f.length()];// 获取文件的字节长度
502 
503             is.read(b);
504 
505             System.out.println(new String(b));// 转换成字符串输出
506 
507         } catch (IOException e) {
508             System.out.println("IO异常，失败");
509             e.printStackTrace();
510         } finally {
511 
512             try {
513 
514                 is.close();
515 
516             } catch (IOException e) {
517                 System.out.println("IO异常，失败");
518                 e.printStackTrace();
519             }
520 
521         }
522 
523     }
524 
525     /**
526      * 文件输出字节流
527      */
528     private static void testFileOutputStream() {
529 
530         OutputStream os = null;
531 
532         try {
533 
534             String str = "我在等你，等下完这场雨\r\n" + "满城涓涤，净此生的别离\r\n" + "心太入戏，梦流转四季只是回忆\r\n" + "手中焰火向谁泣\r\n"
535                     + "如果可以，别下完这场雨\r\n" + "放慢朝夕，拾与你的点滴\r\n" + "怕来不及，回眸再重温此刻如往昔\r\n" + "伞外朦胧可是你\r\n";// "\r\n"是Windows系统的换行
536 
537             File f = new File("D:\\IO\\testFileOutputStream.txt");
538 
539             os = new FileOutputStream(f);
540 
541             os.write(str.getBytes());// 获取字节数组
542 
543             System.out.println("完成");
544 
545         } catch (IOException e) {
546             System.out.println("IO异常，失败");
547             e.printStackTrace();
548         } finally {
549 
550             try {
551 
552                 os.close();
553 
554             } catch (IOException e) {
555                 System.out.println("IO异常，失败");
556                 e.printStackTrace();
557             }
558 
559         }
560 
561     }
562 
563 }