黑马程序员_IO_字符流（FileReader,FileWriter,BufferWriter）文件copy

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

    IO（Input Output）

         IO

         输入流和输出流相对于内存设备而言

                   将外设中的数据读取到内存中，输入

                   将内存中的数据写入到外设中，输出

                  

                   字符流的由来：

                   其实就是：字节流读取文字字节数据后，不直接操作而是先查指定的编码表，获取对应的文字。

                   而对这个文字进行操作，简单说：字节流+编码表

                  

                   字节流的顶层父类InputStream  OutputStream

                   字符流的两个顶层父类：Reader   Writer

      FileWriter:

                   既然是往一个文件中写入文字数据，那么在创建对象时。就必须明确该文件（目的地）

                   如果文件不存在，则自动创建，如果存在，则覆盖掉原来的文件

                  

                   从内存中把数据写入到文件中，其实第一步是先写入到输出流中。

                   必须经过刷新才能立即写入到目标文件

                   关闭流时，会强制自动刷新。

                   如果关闭流后，在刷新和写入流，会发生IOException()

                   FileWriterfw = new FileWriter("deom.txt");

                  

                   fw.write("sdds");

                   fw.flush(;

                   fw.close();

                  

                   如果是换行：则System.getProperty("line.separator");

                   如果构造方法加入true,可以实现对文件的续写。

                   FileWriterfw = new FileWriter("deom.txt",true);

      异常处理

                   FileWriterfw = null;

 

                   try{

                                               fw= new FileWriter("demo.txt");

                                               fw.write("sds");

                            }catch (Exception e) {

                                     //TODO: handle exception

                                     if(fw!=null){

                                               try{

                                                        fw.close();

                                               }catch (IOException e1) {

                                                        //TODO Auto-generated catch block

                                                        thrownew RuntimeException("关闭失败");

                                               }

                                     }

                            }

      FileReader

                   read()读取单个字符，返回的是该字符的字节数，如果读完，则返回-1

                   FileReaderfr = new FileReader("demo.txt");

                   intth = 0;

                   while((th=(fr.read()))!=-1){

                            System.out.println((char)th);

                   }

                   intread(char[]a) 读取单个字符，到a数组中，如果能把字符数组填满，则填满

                   ，否则，如果读完，则返回-1，不然返回，读到数组中字符数。

                   char[] buf = new char[10];

                   intlen = 0;

                   while((len=fr.read(buf))!=-1){

                            newString(buf,0,len);

                  }

      文件的复制

                            packagecom.sdut.day10;

 

                   importjava.io.FileReader;

                   importjava.io.FileWriter;

                   importjava.io.IOException;

 

                   publicclass ReadeWrter {

 

                            privatestatic final int BUFFE_SIZE = 1024;

 

                            publicstatic void main(String[] args) {

                                     Stringsour = "D:\\t1.txt";

                                     Stringdes= "E:\\t2.txt";

                                     readWreteFile(sour,des);

                            }

 

                            privatestatic void readWreteFile(String sour, String des) {

                                     FileReaderfr  = null;

                                     FileWriterfw = null;

                                     try{

                                               fr=newFileReader(sour);

                                               fw= new FileWriter(des);

                                               intlen = 0 ;

                                               chara[] = new char[BUFFE_SIZE];

                                               while((len= fr.read(a))!=-1){

                                                        fw.write(a,0, len);

                                                        fw.flush();

                                               }

                                               System.out.println("读取成功");

                                     }

                                     catch(IOExceptione){

                                               e.printStackTrace();

                                     }

                                     finally{

                                               if(fr!=null){

                                                        try{

                                                                 fr.close();

                                                        }catch (IOException e) {

                                                                 //TODO Auto-generated catch block

                                                                 e.printStackTrace();

                                                        }

                                               }

                                               if(fw!=null){

                                                        try{

                                                                 fw.close();

                                                        }catch (IOException e) {

                                                                 //TODO Auto-generated catch block

                                                                 e.printStackTrace();

                                                        }

                                               }

                           

                                     }

                                    

                                    

                            }

 

                   }

BufferedWriter

         FileWriterfw = new FileWriter("buf.txt");

        

         BufferedWriterbw = new BufferedWriter(fw);

        

         //bw.write("sdsdsdsdsdsdsd"+System.getProperty(line.seperator)+"sdd");//换行的写入

         bw.write("sds");

         bw.newLine();//换行

         bw.write("sds");

         bw.flush();

         bw.close();//其实关闭的是输出流

BufferedReader

         FileReaderfr = new FileReader("buf.txt");

        

         BufferedReaderbr = new BufferedReader(fr);

         Stringline =  null;

         while((line=br.readLine())!=null){

                   System.out.println(line);

         }

         readLine()原理：

                   使用了读取缓冲区的Read()方法，将读取的字符进行缓冲并判断换行标记，将标记前的数据

                   转为字符串进行返回    

         自定义的读缓冲区。

                   classmyReadLine{

                            privateFileReader r;

                            //缓冲区的原理：其实就是从源中获取一批数据到缓冲区中

                            //从缓冲区中不断的取出一个个数据

                            MyReadLine(FileReaderr){

                                     this.r= r;

                            }

                            //定义一个数组作为缓冲区

                            char[]buf = new char[1024];

                            //定义一个指针用于操作这个数组中的元素，当操作到最后一个元素后，指针应该归零

                            intpos=0;

                            //定义一个计数器，用于记录缓冲区个数，当数据减为0，在从源中取数据

                            intcount=0;

                            //定义一个StringBuilder，用来接受从缓冲区中读取的数据。

                            publicint myRead(){

                                     if(count==0){

                                               count=r.read(buf);

                                               pos= 0;

                                     }

                                     if(count<0){

                                               return-1;

                                     }

                                     charc = buf[pos];

                                     pos++;

                                     count--;

                                     returnc;

                            }

                            publicString myReadLine(){

                                     StringBuildersb = new StringBuilder();

                                     inta = this.myRead();

                                     while(a!=-1){

                                               if(a=='\r')

                                               continue;

                                               if(a=='\n')

                                               returnsb.toString();

                                               sb.append((char)a);

                                               a= this.myRead();

                                     }

                                     if(sb.length()>0){

                                               returnsb.toString();

                                     }

                            }

                            publicvoid myClose(){

                                     r.close();

                            }

                   }