java中的IO操做总结（一）

转载： http://www.cnblogs.com/nerxious/archive/2012/12/15/2818848.html  

  所谓IO，也就是Input与Output的缩写。在java中，IO涉及的范围比较大，这里主要讨论针对文件内容的读写

其余知识点将放置后续章节（我想，文章太长了，谁都没耐心翻到最后）

对于文件内容的操做主要分为两大类

分别是：

　　字符流

　　字节流

其中，字符流有两个抽象类：Writer ，Reader

其对应子类FileWriter和FileReader可实现文件的读写操做

BufferedWriter和BufferedReader可以提供缓冲区功能，用以提升效率

 

一样，字节流也有两个抽象类：InputStream   OutputStream

其对应子类有FileInputStream和FileOutputStream实现文件读写

BufferedInputStream和BufferedOutputStream提供缓冲区功能

 

俺当初学IO的时候犯了很多迷糊，网上有些代码也没法经过编译，甚至风格都很大不一样，因此新手请注意：       

        1.本文代码较长，不应省略的都没省略，主要是由于做为一个新手须要养成良好的代码编写习惯

　　 2.本文在linux下编译，相似于File.pathSeparator和File.separator这种表示方法是出于跨平台性和健壮性考虑

　　 3.代码中有些操做有多种执行方式，我采用了方式1...方式2...的表述，只需轻轻解开注释即可编译

　　 4.代码中并无在主方法上抛出异常，而是分别捕捉，形成代码过长，若是仅是测试，或者不想有好的编程习惯，那你就随便抛吧……

        5.功能相似的地方就没有重复写注释了，若是新手看不懂下面的代码，那确定是上面的没有理解清楚

 

字符流

实例1：字符流的写入

 
       
       import java.io.File;
 
       
       import java.io.FileWriter;
 
       
       import java.io.IOException;

 
       
       public class Demo {
 
       
           public static void main(String[] args ) {

 
       
               //建立要操做的文件路径和名称
 
       
               //其中，File.separator表示系统相关的分隔符，Linux下为：/  Windows下为：\\
 
       
               String path = File.separator + "home" + File.separator + "siu" +
 
       
                             File.separator + "work" + File.separator + "demo.txt";

 
       
               //因为IO操做会抛出异常，所以在try语句块的外部定义FileWriter的引用
 
       
               FileWriter w = null;
 
       
               try {
 
       
                   //以path为路径建立一个新的FileWriter对象
 
       
                   //若是须要追加数据，而不是覆盖，则使用FileWriter（path，true）构造方法
 
       
                   w = new FileWriter(path);

 
       
                   //将字符串写入到流中，\r\n表示换行想有好的
 
       
                   w.write("Nerxious is a good boy\r\n");
 
       
                   //若是想立刻看到写入效果，则须要调用w.flush()方法
 
       
                   w.flush();
 
       
               } catch (IOException e) {
 
       
                   e.printStackTrace();
 
       
               } finally {
 
       
                   //若是前面发生异常，那么是没法产生w对象的
 
       
                   //所以要作出判断，以避免发生空指针异常
 
       
                   if(w != null) {
 
       
                       try {
 
       
                           //关闭流资源，须要再次捕捉异常
 
       
                           w.close();
 
       
                       } catch (IOException e) {
 
       
                           e.printStackTrace();
 
       
                       }
 
       
                   }
 
       
               }
 
       
           }
 
       
       }

编译以后，在目录下面生成文件，并写入字符串

 

实例2：字符流的读取

 

 
       
       import java.io.File;
 
       
       import java.io.FileReader;
 
       
       import java.io.IOException;

 
       
       public class Demo2 {
 
       
           public static void main(String[] args ) {
 
       
               String path = File.separator + "home" + File.separator + "siu" +
 
       
                             File.separator + "work" + File.separator + "demo.txt";

 
       
               FileReader r = null;
 
       
               try {
 
       
                   r = new FileReader(path);

 
       
                   //方式一：读取单个字符的方式
 
       
                   //每读取一次，向下移动一个字符单位
 
       
                   int temp1 = r.read();
 
       
                   System.out.println((char)temp1);
 
       
                   int temp2 = r.read();
 
       
                   System.out.println((char)temp2);

 
       
                   //方式二：循环读取
 
       
                   //read()方法读到文件末尾会返回-1
 
       
                   /*
 
       
                   while (true) {
 
       
                       int temp = r.read();
 
       
                       if (temp == -1) {
 
       
                           break;
 
       
                       }
 
       
                       System.out.print((char)temp);
 
       
                   }
 
       
                   */

 
       
                   //方式三：循环读取的简化操做
 
       
                   //单个字符读取，当temp不等于-1的时候打印字符
 
       
                   /*int temp = 0;
 
       
                   while ((temp = r.read()) != -1) {
 
       
                       System.out.print((char)temp);
 
       
                   }
 
       
                   */

 
       
                   //方式四：读入到字符数组
 
       
                   /*
 
       
                   char[] buf = new char[1024];
 
       
                   int temp = r.read(buf);
 
       
                   //将数组转化为字符串打印,后面参数的意思是
 
       
                   //若是字符数组未满，转化成字符串打印后尾部也许会出现其余字符
 
       
                   //所以，读取的字符有多少个，就转化多少为字符串
 
       
                   System.out.println(new String(buf,0,temp));
 
       
                   */

 
       
                   //方式五：读入到字符数组的优化
 
       
                   //因为有时候文件太大，没法肯定须要定义的数组大小
 
       
                   //所以通常定义数组长度为1024，采用循环的方式读入
 
       
                   /*
 
       
                   char[] buf = new char[1024];
 
       
                   int temp = 0;
 
       
                   while((temp = r.read(buf)) != -1) {
 
       
                       System.out.print(new String(buf,0,temp));
 
       
                   }
 
       
                   */

 
       
               } catch (IOException e) {
 
       
                   e.printStackTrace();
 
       
               } finally {
 
       
                   if(r != null) {
 
       
                       try {
 
       
                           r.close();
 
       
                       } catch (IOException e) {
 
       
                           e.printStackTrace();
 
       
                       }
 
       
                   }
 
       
               }
 
       
           }
 
       
       }

编译以后的效果：

 

实例3：文本文件的复制

 
       
       import java.io.File;
 
       
       import java.io.FileReader;
 
       
       import java.io.FileWriter;
 
       
       import java.io.IOException;

 
       
       public class Demo {
 
       
           public static void main(String[] args ) {

 
       
               String doc = File.separator + "home" + File.separator + "siu" +
 
       
                             File.separator + "work" + File.separator + "demo.txt";

 
       
               String copy = File.separator + "home" + File.separator + "siu" +
 
       
                            File.separator + "life" + File.separator + "lrc.txt";

 
       
               FileReader r = null;
 
       
               FileWriter w = null;
 
       
               try {
 
       
                   r = new FileReader(doc);
 
       
                   w = new FileWriter(copy);

 
       
                   //方式一：单个字符写入
 
       
                   int temp = 0;
 
       
                   while((temp = r.read()) != -1) {
 
       
                       w.write(temp);
 
       
                   }

 
       
                   //方式二：字符数组方式写入
 
       
                   /*
 
       
                   char[] buf = new char[1024];
 
       
                   int temp = 0;
 
       
                   while ((temp = r.read(buf)) != -1) {
 
       
                       w.write(new String(buf,0,temp));
 
       
                   }
 
       
                   */

 
       
               } catch (IOException e) {
 
       
                   e.printStackTrace();
 
       
               } finally {
 
       
                   //分别判断是否空指针引用，而后关闭流
 
       
                   if(r != null) {
 
       
                       try {
 
       
                           r.close();
 
       
                       } catch (IOException e) {
 
       
                           e.printStackTrace();
 
       
                       }
 
       
                   }
 
       
                   if(w != null) {
 
       
                       try {
 
       
                           w.close();
 
       
                       } catch (IOException e) {
 
       
                           e.printStackTrace();
 
       
                       }
 
       
                   }
 
       
               }
 
       
           }
 
       
       }

 

 

实例4：利用字符流的缓冲区来进行文本文件的复制

 

 
       
       import java.io.BufferedReader;
 
       
       import java.io.BufferedWriter;
 
       
       import java.io.File;
 
       
       import java.io.FileReader;
 
       
       import java.io.FileWriter;
 
       
       import java.io.IOException;

 
       
       public class Demo {
 
       
           public static void main(String[] args ) {

 
       
               String doc = File.separator + "home" + File.separator + "siu" +
 
       
                             File.separator + "work" + File.separator + "demo.txt";

 
       
               String copy = File.separator + "home" + File.separator + "siu" +
 
       
                            File.separator + "life" + File.separator + "lrc.txt";

 
       
               FileReader r = null;
 
       
               FileWriter w = null;
 
       
               //建立缓冲区的引用
 
       
               BufferedReader br = null;
 
       
               BufferedWriter bw = null;
 
       
               try {
 
       
                   r = new FileReader(doc);
 
       
                   w = new FileWriter(copy);
 
       
                   //建立缓冲区对象
 
       
                   //将须要提升效率的FileReader和FileWriter对象放入其构造函数内
 
       
                   //固然，也能够使用匿名对象的方式 br = new BufferedReader(new FileReader(doc));
 
       
                   br = new BufferedReader(r);
 
       
                   bw = new BufferedWriter(w);

 
       
                   String line = null;
 
       
                   //读取行，直到返回null
 
       
                   //readLine()方法只返回换行符以前的数据
 
       
                   while((line = br.readLine()) != null) {
 
       
                       //使用BufferWriter对象的写入方法
 
       
                       bw.write(line);
 
       
                       //写完文件内容以后换行
 
       
                       //newLine()方法依据平台而定
 
       
                       //windows下的换行是\r\n
 
       
                       //Linux下则是\n
 
       
                       bw.newLine();
 
       
                   }

 
       
               } catch (IOException e) {
 
       
                   e.printStackTrace();
 
       
               } finally {
 
       
                   //此处再也不须要捕捉FileReader和FileWriter对象的异常
 
       
                   //关闭缓冲区就是关闭缓冲区中的流对象
 
       
                   if(br != null) {
 
       
                       try {
 
       
                           r.close();
 
       
                       } catch (IOException e) {
 
       
                           e.printStackTrace();
 
       
                       }
 
       
                   }
 
       
                   if(bw != null) {
 
       
                       try {
 
       
                           bw.close();
 
       
                       } catch (IOException e) {
 
       
                           e.printStackTrace();
 
       
                       }
 
       
                   }
 
       
               }
 
       
           }
 
       
       }