IO字符流

--

    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();

                                                        }

                                               }

                           

                                     }

                                    

                                    

                            }

 

                   }