码迷,mamicode.com
首页 > 其他好文 > 详细

IO流

时间:2015-07-23 21:25:38      阅读:200      评论:0      收藏:0      [点我收藏+]

标签:

 

一、IO流是什么?

IO流就是InputOutput的缩写。

它的特点:

        1、IO流用来处理设备间的数据传输。

        2、Java对数据的操作是通过流的方式。

        3、Java用于操作流的对象都在IO包中。

        4、流按操作数据分为两种:字节流和字符流。

        5、流按流向分为:输入流和输出流。

注意事项:流只能操作数据,而不能操作文件。

IO流的常用基类:

        1、字节流的抽象基流:InputStream和OutputStream

        2、字符流的抽象基流:Reader和Writer

注:此四个类派生出来的子类名称都是以父类名作为子类名的后缀;如InputStream子类FileInputStream;Reader子类FileReader。 二、 字符流

概述        

、字符流中的对象融合了编码表。使用的是默认的编码,即当前系统的编码。

2、字符流只用于处理文字数据,而字节流可以处理媒体数据。

3、既然IO流是用于操作数据的,那么数据的最常见体现形式是文件。查看API,找到一个专门用于操作文件的Writer子类对象:FileWriter。    后缀是父类名。前缀名是流对象的功能。该流对象一被初始化,就必须有被操作的文件存在。

 字符流的读写

1、写入字符流步骤

        a、创建一个FileWriter对象,该对象一被初始化,就必须要明确被操作的文件。且该目录下如果已有同名文件,则同名文件将                     被覆盖。其实该步就是在明确数据要存放的目的地。

        b、调用write(String s)方法,将字符串写入到流中。

        c、调用flush()方法,刷新该流的缓冲,将数据刷新到目的地中。

        d、调用close()方法,关闭流资源。但是关闭前会刷新一次内部的缓冲数据,并将数据刷新到目的地中。

close()和flush()区别:

       flush()刷新后,流可以继续使用;

       而close()刷新后,将会关闭流,不可再写入字符流。

注意:        

1、其实java自身不能写入数据,而是调用系统内部方式完成数据的书写,使用系统资源后,一定要关闭资源。

2、文件的数据的续写是通过构造函数 FileWriter(Strings,boolean append),在创建对象时,传递一个true参数,代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。(windows系统中的文件内换行用\r\n两个转义字符表示,在linux系统中只用\n表示换行)

3、由于在创建对象时,需要指定创建文件位置,如果指定的位置不存在,就会发生IOException异常,所以在整个步骤中,需要对IO异常进行try处理。

 示例:

  1. import java.io.*;  
  2.   
  3. class FileWriterDemo   
  4. {  
  5.     public static void main(String[] args)   
  6.     {  
  7.         writerDate("abcde");//写入数据  
  8.         writerFrom("zheshi:\r\nshenma");//续写数据,并附换行操作  
  9.     }  
  10.   
  11.     //在硬盘上创建一个文件并写入指定数据  
  12.     public static void writerDate(String s)  
  13.     {  
  14.         FileWriter fw=null;  
  15.         try  
  16.         {  
  17.             fw=new FileWriter("demo.txt");//创建文件  
  18.             fw.write(s);//将数据写入流  
  19.         }  
  20.         catch (IOException e)  
  21.         {  
  22.             throw new RuntimeException("写入失败");  
  23.         }  
  24.         finally  
  25.         {  
  26.             if(fw!=null)  
  27.                 try  
  28.                 {  
  29.                     fw.close();//将写入流的数据刷到指定文件内,并关闭流资源  
  30.                 }  
  31.                 catch (IOException e)  
  32.                 {  
  33.                 }  
  34.         }  
  35.     }  
  36.   
  37.     //对已有文件的数据续写指定数据  
  38.     public static void writerFrom(String s)  
  39.     {  
  40.         FileWriter fw=null;  
  41.         try  
  42.         {  
  43.             fw=new FileWriter("demo.txt",true);//传递一个true参数,代表不覆盖已有的文件。  
  44.             fw.write(s);  
  45.         }  
  46.         catch (IOException e)  
  47.         {  
  48.             throw new RuntimeException("写入失败");  
  49.         }  
  50.         finally  
  51.         {  
  52.             try  
  53.             {  
  54.                 if(fw!=null)  
  55.                     fw.close();  
  56.             }  
  57.             catch (IOException e)  
  58.             {  
  59.             }  
  60.         }  
  61.     }  
  62. }  

2、读取字符流步骤

        1)创建一个文件读取流对象,和指定名称的文件相关联。要保证该文件已经存在,若不存在,将会发生异常FileNotFoundException。

        2)调用读取流对象的read()方法。read():一次读一个字符,且会继续往下读。

              第一种方式:读取单个字符。第二种方式:通过字符数组进行读取。

        3)读取后要调用close方法将流资源关闭。

示例:

  1. import java.io.*;  
  2. class  FileReaderDemo  
  3. {  
  4.     public static void main(String[] args)   
  5.     {  
  6.         //第一种读取方式  
  7.         singleCharReader();  
  8.         //第二种读取方式  
  9.         arrayCharReader();  
  10.     }  
  11.   
  12.     //第一种读取方式,单个字符读取  
  13.     public static void singleCharReader()  
  14.     {  
  15.         FileReader fr=null;  
  16.         try  
  17.         {  
  18.               
  19.             fr=new FileReader("demo.txt");//读取文件位置和文件名  
  20.             for (int ch=0;(ch=fr.read())!=-1 ; )  
  21.             {  
  22.                 System.out.print((char)ch);  
  23.             }  
  24.         }  
  25.         catch (IOException e)  
  26.         {  
  27.             throw new RuntimeException("读取失败");  
  28.         }  
  29.         finally  
  30.         {  
  31.             try  
  32.             {  
  33.                 if(fr!=null)  
  34.                     fr.close();//关闭读取流资源  
  35.             }  
  36.             catch (IOException e)  
  37.             {  
  38.             }  
  39.         }  
  40.     }  
  41.   
  42.     //第二种读取方式,通过字符数组进行读取  
  43.     public static void arrayCharReader()  
  44.     {  
  45.         FileReader fr=null;  
  46.         char[] arr=new char[1024];//定义一个字符数组,用于临时存储读取的字符  
  47.         try  
  48.         {  
  49.             //读取一个.java文件,并打印在控制台上。  
  50.             fr=new FileReader("FileReaderDemo.java");  
  51.             for (int len=0;(len=fr.read(arr))!=-1 ; )  
  52.             {  
  53.                 //显示字符数组的字符个数  
  54.                 System.out.print(new String(arr,0,len));  
  55.             }  
  56.         }  
  57.         catch (IOException e)  
  58.         {  
  59.             throw new RuntimeException("读取失败");  
  60.         }  
  61.         finally  
  62.         {  
  63.             if(fr!=null)  
  64.                 try  
  65.                 {  
  66.                     fr.close();  
  67.                 }  
  68.                 catch (IOException e)  
  69.                 {  
  70.                 }  
  71.         }  
  72.     }  
  73. }  

注意:

        1、定义文件路径时,可以用“/”或者“\\”。

        2、在创建一个文件时,如果目录下有同名文件将被覆盖。

        3、在读取文件时,必须保证该文件已存在,否则出异常。

练习:文本文件的拷贝

  1. /* 
  2. 需求: 
  3. 将c盘一个文本文件复制到e盘、 
  4. 复制的原理: 
  5. 其实就是将c盘下的文件数据存储到e盘的一个文件中。 
  6. 步骤: 
  7. 1、在e盘创建一个文件。用于存储c盘文件中的数据。 
  8. 2、定义读取流和c盘文件关联。 
  9. 3、通过不断的读写完成数据存储。 
  10. 4、关闭资源。 
  11. */  
  12. import java.io.*;  
  13.    
  14. class ReaderWriterTest  
  15. {  
  16.        publicstatic void main(String[] args)   
  17.        {  
  18.               //调用复制方法  
  19.               //copy_1();  
  20.               copy_2();  
  21.        }  
  22.        //用第一种读取方式进行复制  
  23.        publicstatic void copy_1()  
  24.        {  
  25.               FileWriterfw=null;  
  26.               FileReaderfr=null;  
  27.               try  
  28.               {  
  29.                      //关联读取和写入的文件  
  30.                      fw=newFileWriter("E:\\HelloWorld.java");  
  31.                      fr=newFileReader("C:\\HelloWorld.java");  
  32.                      for(int ch=0;(ch=fr.read())!=-1 ; )  
  33.                      {  
  34.                             fw.write(ch);//一个字符一个字符写入  
  35.                      }  
  36.               }  
  37.               catch(IOException e)  
  38.               {  
  39.                      thrownew RuntimeException("读写失败");  
  40.               }  
  41.               finally  
  42.               {  
  43.                      if(fr!=null)  
  44.                             try  
  45.                             {  
  46.                                    fr.close();//对读取流和写入流分别关闭  
  47.                             }  
  48.                             catch(IOException e)  
  49.                             {  
  50.                             }  
  51.                      if(fw!=null)  
  52.                             try  
  53.                             {  
  54.                                    fw.close();  
  55.                             }  
  56.                             catch(IOException e)  
  57.                             {  
  58.                             }  
  59.               }  
  60.        }  
  61.    
  62.        //第二种读取方式进行复制  
  63.        publicstatic void copy_2()  
  64.        {  
  65.               FileWriterfw=null;  
  66.               FileReaderfr=null;  
  67.               try  
  68.               {  
  69.                      //关联读取和写入的文件  
  70.                      fw=newFileWriter("E:\\HelloWorld.java");  
  71.                      fr=newFileReader("C:\\HelloWorld.java");  
  72.                      char[]arr=new char[1024];  
  73.                      for(int len=0;(len=fr.read(arr))!=-1 ; )  
  74.                      {  
  75.                             fw.write(arr,0,len);//利用数组一次存入数组中的字符  
  76.                      }  
  77.               }  
  78.               catch(IOException e)  
  79.               {  
  80.                      thrownew RuntimeException("读写失败");  
  81.               }  
  82.               finally  
  83.               {  
  84.                             try  
  85.                             {  
  86.                                    if(fr!=null)  
  87.                                           fr.close();  
  88.                             }  
  89.                             catch(IOException e)  
  90.                             {  
  91.                             }  
  92.                             finally  
  93.                             {  
  94.                                    if(fw!=null)  
  95.                                           try  
  96.                                           {  
  97.                                                  fw.close();  
  98.                                           }  
  99.                                           catch(IOException e)  
  100.                                           {  
  101.                                           }  
  102.                             }       
  103.               }  
  104.        }  
  105. }  

字符流的缓冲区 :         

BufferedReader和BufferedWriter

1、缓冲区的出现:提高了流的读写效率,所以在缓冲区创建前,要先创建流对象。即先将流对象初始化到构造函数中。 

2、缓冲技术原理:此对象中封装了数组,将数据存入,再一次性取出。

3、写入流缓冲区BufferedWriter的步骤:

         1)创建一个字符写入流对象。

         如:FileWriter fw=newFileWriter("buf.txt");

         2)为了提高字符写入流效率。加入缓冲技术。只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。

         如: BufferedWriter bufw =new BufferedWriter(fw);

         3)调用write方法写入数据到指定文件

         如:bufw.write("adfg");

      记住,只要用到缓冲区,就要记得刷新。(关闭流同样会刷新,但为了排除意外事故,保证数据存在,建议写入一次就刷新一次)

         如:bufw.flush();

         4)其实关闭缓冲区,就是在关闭缓冲区中的流对象。

        如: bufw.close();

小知识:BufferedWriter缓冲区中提供了一个跨平台的换行符:newLine();可以在不同操作系统上调用,用作数据换行。

        如:bufw.newLine();

4、读取流缓冲区BufferedReader

        该缓冲区提供了一个一次读一行的方法readLine,方便于堆文本数据的获取,当返回null时表示读到文件末尾。readLine方法返回的时候,只返回回车符之前的数据内容。并不返回回车符。

readLine方法原理:

        无论是读一行。或者读取多个字符。其实最终都是在在硬盘上一个一个读取。所以最终使用的还是read方法一次读一个的方法。

步骤:

        1)创建一个读取流对象和文件相关联

        如: FileReader fr=newFileReader("buf.txt");

        2)为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲区对象的构造函数。

        如: BufferedReader bufr=new BufferedReader(fr);

        3)调用该缓冲区提供的readLine方法一行一行读取,如果到达文件末尾,则返回null

        如: String s=bufr.readLine();

        4)关闭流资源

        如: bufr.close();、

示例:通过缓冲区复制一个文本文件。

  1. /* 
  2. 需求:使用缓冲技术copy一个文本文件 
  3. */  
  4. import java.io.*;  
  5.   
  6. class BufferedCopyDemo   
  7. {  
  8.     public static void main(String[] args)   
  9.     {  
  10.           
  11.         BufferedWriter bfw=null;  
  12.         BufferedReader bfr=null;  
  13.         try  
  14.         {  
  15.             //创建写缓冲对象  
  16.             bfw=new BufferedWriter(new FileWriter("ReaderWriterTest_copy.txt"));  
  17.             //创建读缓冲对象  
  18.             bfr=new BufferedReader(new FileReader("ReaderWriterTest.java"));  
  19.             //利用BufferedReader提供的readLine方法获取整行的有效字符。直到全部获取  
  20.             for (String line=null; (line=bfr.readLine())!=null; )  
  21.             {  
  22.                 bfw.write(line);//写入指定文件中  
  23.                 bfw.newLine();//换行  
  24.                 bfw.flush();//将缓冲区数据刷到指定文件中  
  25.             }  
  26.               
  27.         }  
  28.         catch (IOException e)  
  29.         {  
  30.             throw new RuntimeException("文件copy失败");  
  31.         }  
  32.         finally  
  33.         {  
  34.             if(bfw!=null)  
  35.                 try  
  36.                 {  
  37.                     bfw.close();//关闭写入流  
  38.                 }  
  39.                 catch (IOException e)  
  40.                 {  
  41.                     throw new RuntimeException("写入流关闭失败");  
  42.                 }  
  43.             if(bfr!=null)  
  44.                 try  
  45.                 {  
  46.                     bfr.close();//关闭读取流  
  47.                 }  
  48.                 catch (IOException e)  
  49.                 {  
  50.                     throw new RuntimeException("读取流关闭失败");  
  51.                 }  
  52.         }  
  53.     }  
  54. }  

 

三、装饰设计模式

1、简述

        当想对已有对象进行功能增强时,可定义类:将已有对象传入,基于已有对象的功能,并提供加强功能,那么自定义的该类称之为装饰类。

2、特点

        装饰类通常都会通过构造方法接收被装饰的对象,并基于被装饰的对象的功能,提供更强的功能。

3、装饰和继承的区别:

        1)装饰模式比继承要灵活。避免了继承体系的臃肿,且降低了类与类之间的关系。

        2)装饰类因为增强已有对象,具备的功能和已有的是相同的,只不过提供了更强的功能,所以装饰类和被装饰的类通常都是属于一个体系。

        3)从继承结构转为组合结构。

注:在定义类的时候,不要以继承为主;可通过装饰设计模式进行增强类功能。灵活性较强,当装饰类中的功能不适合,可再使用被装饰类的功能。

 

IO流

标签:

原文地址:http://www.cnblogs.com/huihui10/p/4671591.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!