黑马程序员——java学习12（毕18--总结）——IO

 1 import java.io.FileWriter;
 2 import java.io.IOException;
 3 
 4 /*
 5  * 字符流和字节流
 6  * 
 7  * 字节流两个基类
 8  * InputStream OutputStream
 9  * 
10  * 字符流两个基类
11  * Reader Writer
12  * 
13  * 先学习一下字符流的特点
14  * 既然IO流是用于操作数据的
15  * 那么数据的最常见体现形式是文件
16  * 
17  * 那么先以操作文件为主来演示
18  * 需求： 在硬盘上，创建一个文件并写入一些文字数据
19  * 
20  * 找到一个专门用于操作文件的Writer子类对象，FileWriter。后缀名是父类名，前缀名是该流对象的功能
21  * */
22 public class FileWriterDemo {
23     public static void main(String[] args) throws IOException{
24         //创建一个FileWriter对象，该对象以被初始化就必须要明确被操作的文件
25         //而且该文件会被创建到制定目录下，如果该目录下已有同名文件，会被覆盖
26         //其实就是明确数据要存放的目的地
27         FileWriter fw = new FileWriter("demo.txt");
28         
29         //调用write方法，将字符串写入到流中
30         fw.write("abcde");
31         
32         //刷新流对象中的缓冲中的数据
33 //        fw.flush();
34         
35         
36         //关闭流资源，但是关闭之前会刷新一次内部缓冲数据
37         //将数据刷到目的地中，和flush的区别在于
38         //和flush区别，flush刷新后，流可以继续使用，close刷新后会将流关闭
39         fw.close();
40     }
41     
42 }

 1 package learn;
 2 
 3 import java.io.FileWriter;
 4 import java.io.IOException;
 5 
 6 /*IO异常的处理方式
 7  * 
 8  * */
 9 public class FileWriterDemo2 {
10     public static void main(String[] args) {
11             FileWriter fw =null;//对象的建立和引用的挂钩分开写
12         try
13         {
14             //fw创建失败则不可能添加数据，故放在一个try中
15              fw = new FileWriter("demo.txt");
16             fw.write("abcdefg");
17         
18         }
19         catch(IOException e)
20         {
21             System.out.println(e.toString());
22         }
23         //必须要关闭流，所以必须写finally,
24         //但是因可能出现没流建立成功，没流能关闭，所以也将关闭写作异常
25         //finally的执行也需要 fw不为空时才可以
26         finally
27         {
28             try
29             {    
30                 if(fw!=null)
31                 fw.close();
32             }
33             catch(IOException e)
34             {
35                 System.out.println(e.toString());
36             }
37             
38         }
39         
40     }
41 }

 1 package learn;
 2 
 3 import java.io.FileWriter;
 4 import java.io.IOException;
 5 
 6 /*
 7  * 演示对已有文件的数据续写
 8  * */
 9 public class FileWriterDemo3 {
10     public static void main(String[] args) throws IOException{
11         //传递一个true参数，代表不覆盖已有的文件，并在已有文件末尾处进行数据续写
12         FileWriter fw= new FileWriter("demo.txt",true);
13         fw.write("ha\r\nha");
14         fw.close();
15     }
16 }

 1 package learn;
 2 
 3 import java.io.FileReader;
 4 import java.io.IOException;
 5 
 6 public class FileReadDemo {
 7     public static void main(String[] args) throws IOException{
 8         //创建一个文件读取流对象，和指定名称的文件相关联
 9         //要保证文件是已经存在的，如果不存在，会发生异常FileNotFoundException
10         FileReader fr = new FileReader("demo.txt");
11         //调用读取流对象的read方法
12         //read方法一次读一个字符，且会自动往下读
13         int ch = 0;
14         while((ch=fr.read())!=-1)
15         {
16             System.out.println((char)ch);
17         }
18         fr.close();        
19     }
20 }

 1 package learn;
 2 
 3 import java.io.FileReader;
 4 import java.io.IOException;
 5 
 6 public class FileReadDemo2 {
 7     public static void main(String[] args) throws IOException{
 8         FileReader fr = new FileReader("demo.txt");
 9         //定义一个字符数组，用于存储读到字符
10         //该read(char[])返回的是读到字符个数
11         //通常定义new char[1024];
12         //创建字符数组，大小为3
13         char[] buf = new char[3];
14         int num = 0;
15         //读一个存一下
16         while((num = fr.read(buf))!=-1)
17         {
18             System.out.println(new String(buf,0,num));
19         }
20 //        int num = fr.read(buf);
21 //        System.out.println("num="+num+"..."+new String(buf));
22         fr.close();
23     }
24 }

 1 package Test;
 2 
 3 import java.io.FileReader;
 4 import java.io.IOException;
 5 
 6 /*读取一个.java文件，并打印在控制台上*/
 7 public class FileReaderTest {
 8     public static void main(String[] args) throws IOException{
 9         FileReader fr = new FileReader("FileReadDemo.java");
10         char[] buf = new char[1024];
11         int num = 0;
12         while((num = fr.read(buf))!=-1)
13         {
14             System.out.println(new String(buf,0,num));
15         }
16         fr.close();
17     }
18 }

 1 package Test;
 2 
 3 import java.io.FileReader;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 
 7 /*
 8  * 将C盘一个文本文件复制到D盘
 9  * 复制的原理：
10  * 其实就是将C盘下的文件数据存储到D盘的一个文件中
11  * 
12  * 步骤：
13  * 1、在D盘创建文件。用于存储C盘文件中的数据
14  * 2、定义读取流和C盘文件关联
15  * 3、通过不断你的读写完成数据存储
16  * 4、关闭资源
17  * */
18 public class CopyText {
19     public static void main(String[] args) throws IOException {
20         copy2();
21     }
22     //从c盘读一个字符写一个字符
23     public static void copy1 ()throws IOException
24     {
25         //创建目的地
26         FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");
27         //与已有文件关联
28         FileReader fr = new FileReader("FileReadDemo.java");
29         int ch = 0;
30         //有一个字符写一次
31         while((ch=fr.read())!=-1)
32         {
33             fw.write(ch);
34         }
35         fw.close();
36         fr.close();
37         
38     }
39     public static void copy2()
40     {
41         FileWriter fw = null;
42         FileReader fr = null;
43         try
44         {
45             fw = new FileWriter("SystemDe_copy2.txt");
46             fr = new FileReader("FileReadDemo.java");
47             char[] buf= new char[1024];
48             int len = 0;
49             while((len=fr.read(buf))!=-1)
50             {
51                 fw.write(buf,0,len);
52             }
53         }
54         catch(IOException e)
55         {
56             throw new RuntimeException("读写失败");
57         }
58         finally
59         {
60             if(fr!=null)
61             try
62             {
63                 fr.close();
64             }
65             catch(IOException e)
66             {
67             }
68             if(fw!=null)
69             try
70             {
71                 fw.close();
72             }
73             catch(IOException e)
74             {
75             }
76             }
77         }
78     }

 1 package learn;
 2 
 3 import java.io.BufferedWriter;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 
 7 /*
 8  * 缓冲区的出现时为了提高流的操作效率而出现的
 9  * 所以在创建缓冲区之前，必须要先有流对象
10  * 该缓冲区中提供了跨平台的换行符newLine();
11  * */
12 public class BufferedWriterDemo {
13     public static void main(String[] args)throws IOException {
14         //创建字符写入流对象
15         FileWriter fw = new FileWriter("buf.txt");
16         //为了提高字符写入流效率，加入了缓冲技术
17         //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可
18         BufferedWriter bufw = new BufferedWriter(fw);
19         for(int x=1;x<5;x++)
20         {
21             bufw.write("abcd"+x);
22             bufw.newLine();
23             bufw.flush();
24         }
25         
26         //记住，只要用到缓冲区就要记得刷新
27         //其实关闭缓冲区就是在关闭缓冲区中的流对象
28         bufw.flush();
29         bufw.close();
30         
31     }
32 }

 1 package learn;
 2 /*
 3  * 字符流取流缓冲区:
 4  * 该缓冲区提供了一个一次读一行的方法readLine, 方便于对文本数据的获取。
 5  * 当返回null时，表示读到文件末尾。
 6  * */
 7 import java.io.BufferedReader;
 8 import java.io.FileReader;
 9 import java.io.IOException;
10 
11 public class BufferedReaderDemo {
12      public static void main(String[] args) throws IOException{
13         //创建一个读取流对象和文件相关联
14          FileReader fr = new FileReader("buf.txt");
15          //为了提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数
16          BufferedReader bufr = new BufferedReader(fr);
17          String line = null;
18          while((line=bufr.readLine())!=null)
19          {
20              System.out.println(line);
21          }
22 //         String s1 = bufr.readLine();
23 //         System.out.println("s1:"+s1);
24          bufr.close();
25          
26     }
27 }

 1 package learn;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileReader;
 6 import java.io.FileWriter;
 7 import java.io.IOException;
 8 
 9 /*
10  * 通过缓冲区复制一个java文件
11  * readLine不返回车符
12  * */
13 public class CopyTextByBuf {
14     public static void main(String[] args) {
15         BufferedReader bufr = null;
16         BufferedWriter bufw = null;
17         try
18         {
19             bufr = new BufferedReader(new FileReader("FileReadDemo.java"));
20             bufw = new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));
21             String line =null;
22             while((line=bufr.readLine())!=null)
23             {
24                 bufw.write(line);
25                 //不加就在一行
26                 bufw.newLine();
27                 bufw.flush();
28             }
29         }
30         catch(IOException e)
31         {
32             throw new RuntimeException("读写失败");
33         }
34         finally
35         {
36             try
37             {
38                 if(bufr!=null)
39                     bufr.close(); 
40             }
41             catch(Exception e)
42             {
43                 throw new RuntimeException("读取关闭失败");
44             }
45             try
46             {
47                 if(bufw!=null)
48                     bufr.close(); 
49             }
50             catch(Exception e)
51             {
52                 throw new RuntimeException("写入关闭失败");
53             }
54         }
55     }
56 }