Java基础--IO流之字符流-优快云博客

本文链接：https://blog.youkuaiyun.com/q549130180/article/details/45333387

凌风博客原创作品。转载请注明出处：http://blog.youkuaiyun.com/q549130180/article/details/45333387

字符流和字节流

字节流两个基类
InputStream OutputStream

字符流两个基类
Reader Writer

先学习一下字符流的特点

既然IO流是用于操作数据的
那么数据的最常见体现形式是：文件

那么先以操作文件为主来演示

需求：在硬盘上，创建一个文件并写入一些文字数据

找到一个专门用于操作文件的Writer子类对象，FileWriter，后缀名是父类名，前缀名是该流对象的功能。

[java]view plaincopy 
   
 import java.io.*;  
 class FileWriterDemo1  
 {  
     public static void main(String[] args) throws IOException  
     {  
         //创建一个FileWriter对象，该对象一被初始化必须要明确被操作的文件  
         //而且该文件会被创建到指定目录下，如果该目录下已有同名文件，将被覆盖  
         //其实该步就是在明确数据要存放的目的地  
         FileWriter fw = new FileWriter("demo.txt");  
   
         //调用write方法，将字符串写入到流中  
         fw.write("abcde");  
   
         //刷新流对象中的缓冲中的数据  
         //将数据刷到目的地中  
         //fw.flush();  
   
         //关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据，将数据刷到目的地中  
         //和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭  
         fw.close();  
   
         System.out.println("Hello World!");  
     }  
 }  

IO异常的处理方式

[java]view plaincopy 
   
 import java.io.*;  
 class FileWriterDemo2   
 {  
     public static void main(String[] args)   
     {  
         FileWriter fw = null;  
         try  
         {  
             fw = new FileWriter("demo.txt");  
             fw.write("abcde");  
         }  
         catch (IOException e)  
         {  
             System.out.println("catch:"+e.toString());  
         }  
         finally  
         {  
             try  
             {  
                 if(fw!=null)  
                     fw.close();  
             }  
             catch (IOException e)  
             {  
                 System.out.println(e.toString());  
             }  
         }  
           
     }  
 }  

演示对已有文件的数据续写

[java]view plaincopy 
   
 import java.io.*;  
 class FileWriterDemo3   
 {  
     public static void main(String[] args)   
     {  
         //传递一个true参数，代表不覆盖已有的文件，并在已有文件的末尾处进行数据续写  
         FileWriter fw = new FileWriter("demo.txt",true);  
   
         fw.write("nihao\r\nxiexie");  
   
         fw.close();  
     }  
 }  

读取文件

[java]view plaincopy 
   
 import java.io.*;  
 class FileReaderDemo4   
 {  
     public static void main(String[] args) throws IOException  
     {  
         method_2();  
     }  
   
     public static void method_1() throws IOException  
     {  
         //创建一个文件读取流对象，和指定名称的文件相关联  
         //要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException  
         FileReader fr = new FileReader("demo.txt");  
   
         //调用读取流对象的read方法  
         //read():一次读一个字符，而且会自动往下读  
         int ch = 0;  
         while((ch=fr.read())!=-1)  
         {  
             System.out.println((char)ch);  
         }  
           
         /* 
         while (true) 
         { 
             int ch = fr.read(); 
             if(ch==1) 
                 break; 
             System.out.println("ch="+(char)ch); 
         } 
         */  
     }  
   
   
     //第二种方式：通过字符数组进行读取  
     public static void method_2() throws IOException  
     {  
         FileReader fr = new FileReader("demo.txt");  
   
         //定义一个字符数组，用于存储读到字符  
         //该read(char[])返回的是读到字符个数  
         char[] buf = new char[1024];//大小通常定义为1024的倍数  
   
         int num = 0;  
         while ((num=fr.read(buf))!=-1)  
         {  
             System.out.println(new String(buf,0,num));  
         }  
         fr.close();  
     }  
 }  

将C盘一个文本文件复制到D盘

复制的原理
其实就是将C盘下的文件数据存储到D盘的一个文件中。

步骤：
1.在D盘创建一个文件，用于存储C盘文件中的数据
2.定义读取流和C盘文件关联
3.通过不断的读写完成数据存储
4.关闭资源

[java]view plaincopy 
   
 import java.io.*;  
 class CopyText5  
 {  
     public static void main(String[] args)   
     {  
         copy_2();  
     }  
   
     public static void copy_2()  
     {  
         FileWriter fw = null;  
         FileReader fr = null;  
         try  
         {  
             fw = new FileWriter("123.txt");  
             fr = new FileReader("FileWriterDemo1.java");  
   
             char[] buf = new char[1024];  
   
             int len = 0;  
   
             while ((len=fr.read(buf))!=-1)  
             {  
                 fw.write(buf,0,len);  
             }  
         }  
         catch (IOException e)  
         {  
             throw new RuntimeException("读写失败");  
         }finally  
         {  
             if (fr!=null)  
                 try  
                 {  
                     fr.close();  
                 }  
                 catch (IOException e)  
                 {  
                 }  
                 if (fr!=null)  
                 try  
                 {  
                     fw.close();  
                 }  
                 catch (IOException e)  
                 {  
                 }  
         }  
     }  
       
     //从C盘读一个字符，就往D盘写一个字符，效率比较低  
     public static void copy_1()  
     {  
         //创建目的地  
         FileWriter fw = new FileWriter("123.txt");  
         //与已有文件关联  
         FileReader fr = new FileReader("FileWriterDemo1.java");  
   
         int ch = 0;  
         while ((ch=fr.read())!=-1)  
         {  
             fw.write(ch);  
         }  
   
         fw.close();  
         fr.close();  
   
           
               
     }  
 }  

缓冲区的出现是为了提高流的操作效率而出现的

所以在创建缓冲区之前，必须要先有流对象

该缓冲区中提供了一个跨平台的换行符
newLine();

[java]view plaincopy 
   
 import java.io.*;  
 class BufferedWriterDemo6   
 {  
     public static void main(String[] args)   
     {  
         //创建一个字符写入流对象  
         FileWriter fw = new FileWriter("buf.txt");  
   
         //为了提高字符写入流效率，加入了缓冲技术  
         //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可  
         BufferedWriter bufw = new BufferedWriter(fw);  
   
         for (int x = 1;x<5 ;x++ )  
         {  
             bufw.write("abcd"+x);  
             bufw.newLine();  
             bufw.flush();  
         }  
   
         //记住，只要用到缓冲区，就要记得刷新  
         //bufw.flush  
   
         //其实关闭缓冲区，就是在关闭缓冲区中的流对象  
         bufw.close();  
     }  
 }  

字符读取流缓冲区：
该缓冲区提供了一个一次读一行的方法readLine，方便于对文本数据的获取
当返回null时，表示读到文件末尾

readLine方法返回的时候只返回回车符之前的数据内容，并不返回回车符。

[java]view plaincopy 
   
 class BufferedReaderDemo7   
 {  
     public static void main(String[] args)   
     {  
         //创建一个读取流对象和文件相关联  
         FileReader fr = new FileReader("buf.txt");  
   
         //为了提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数  
         BufferedReader bufr = new BufferedReader(fr);  
   
         String line = null;  
         while ((line=bufr.readLine())!=null)  
         {  
             System.out.println(line);  
         }  
         bufr.close();  
     }  
 }  

通过缓冲区复制一个.java文件

[java]view plaincopy 
   
 import java.io.*;  
 class CopyTextByBuf8   
 {  
     public static void main(String[] args)   
     {  
         BufferedReader bufr = null;  
         BufferedWriter bufw = null;  
         try  
         {  
             bufr = new BufferedReader(new FileReader("FileWriterDemo1.java"));  
             bufw = new BufferedWriter(new FileWriter("123.txt"));  
   
             String line = null;  
   
             while ((line=bufr.readLine())!=null)  
             {  
                 bufw.write(line);  
                 bufw.newLine();  
                 bufw.flush();  
             }  
         }  
         catch (IOException e)  
         {  
             throw new RuntimeException("读写失败");  
         }finally  
         {  
             try  
             {  
                 if(bufr!=null)  
                     bufr.close();  
             }  
             catch (IOException e)  
             {  
                 throw new RuntimeException("读取关闭失败");  
             }  
             try  
             {  
                 if(bufw!=null)  
                     bufw.close();  
             }  
             catch (IOException e)  
             {  
                 throw new RuntimeException("写入关闭失败");  
             }  
         }  
     }  
 }  