IO流上:概述字符流缓冲区

Posted lswlsw

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了IO流上:概述字符流缓冲区相关的知识,希望对你有一定的参考价值。

一、IO流概述

概述:

         IO流简单来说就是Input和Output流,IO流主要是用来处理设备之间的数据传输,java对于数据的操作都是通过流实现,而java用于操作流的对象都在IO包中。

分类:

        按操作数据分为:字节流和字符流。 如:Reader和InpurStream

        按流向分:输入流和输出流。如:InputStream和OutputStream

IO流常用的基类:

         * InputStream    ,    OutputStream

字符流的抽象基类:

         * Reader       ,         Writer

由上面四个类派生的子类名称都是以其父类名作为子类的后缀:

            如:FileReader和FileInputStream

二、字符流

1. 字符流简介:

* 字符流中的对象融合了编码表,也就是系统默认的编码表。我们的系统一般都是GBK编码。

* 字符流只用来处理文本数据,字节流用来处理媒体数据。

* 数据最常见的表现方式是文件,字符流用于操作文件的子类一般是FileReader和FileWriter。

2.字符流读写:

注意事项:

* 写入文件后必须要用flush()刷新。

* 用完流后记得要关闭流

* 使用流对象要抛出IO异常

 

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

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

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

示例1:在硬盘上创建一个文件,并写入一些文字数据

 

  1. class FireWriterDemo {  
  2.     public static void main(String[] args) throws IOException {             //需要对IO异常进行处理   
  3.   
  4.         //创建一个FileWriter对象,该对象一被初始化就必须要明确被操作的文件。  
  5.         //而且该文件会被创建到指定目录下。如果该目录有同名文件,那么该文件将被覆盖。  
  6.   
  7.         FileWriter fw = new FileWriter("F:\\1.txt");//目的是明确数据要存放的目的地。  
  8.   
  9.         //调用write的方法将字符串写到流中  
  10.         fw.write("hello world!");  
  11.       
  12.         //刷新流对象缓冲中的数据,将数据刷到目的地中  
  13.         fw.flush();  
  14.   
  15.         //关闭流资源,但是关闭之前会刷新一次内部缓冲中的数据。当我们结束输入时候,必须close();  
  16.         fw.write("first_test");  
  17.         fw.close();  
  18.         //flush和close的区别:flush刷新后可以继续输入,close刷新后不能继续输入。  
  19.   
  20.     }  
  21. }  

示例2:FileReader的reade()方法.

要求:用单个字符和字符数组进行分别读取

 

  1. class FileReaderDemo {  
  2.     public static void main(String[] args) {  
  3.         characters();  
  4.     }  
  5.   
  6.   
  7. /*****************字符数组进行读取*********************/  
  8.     private static void characters() {  
  9.   
  10.         try {  
  11.   
  12.             FileReader fr = new FileReader("Demo.txt");  
  13.             char []  buf = new char[6];   
  14.             //将Denmo中的文件读取到buf数组中。  
  15.             int num = 0;      
  16.             while((num = fr.read(buf))!=-1) {  
  17.   
  18.                 //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符  
  19.                 sop(new String(buf,0,num));  
  20.             }  
  21.             sop(‘\n‘);  
  22.             fr.close();  
  23.         }  
  24.         catch (IOException e) {  
  25.             sop(e.toString());  
  26.         }  
  27.     }  
  28.   
  29.   
  30. /*****************单个字母读取*************************/  
  31.     private static void singleReader() {  
  32.           
  33.         try {  
  34.   
  35.             //创建一个文件读取流对象,和指定名称的文件关联。  
  36.             //要保证文件已经存在,否则会发生异常:FileNotFoundException  
  37.             FileReader fr = new FileReader("Demo.txt");  
  38.   
  39.           
  40.             //如何调用读取流对象的read方法?  
  41.             //read()方法,一次读取一个字符,并且自动往下读。如果到达末尾则返回-1  
  42.             int ch = 0;  
  43.             while ((ch=fr.read())!=-1) {  
  44.                 sop((char)ch);  
  45.             }  
  46.             sop(‘\n‘);  
  47.             fr.close();  
  48.   
  49.   
  50.             /*int ch = fr.read(); 
  51.             sop("ch=" + (char)ch); 
  52.  
  53.             int ch2 = fr.read(); 
  54.             sop("ch2=" + (char)ch2); 
  55.  
  56.             //使用结束注意关闭流 
  57.             fr.close(); */    
  58.               
  59.   
  60.   
  61.         }  
  62.         catch (IOException e) {  
  63.             sop(e.toString());  
  64.         }  
  65.       
  66.     }  
  67.   
  68.   
  69. /**********************Println************************/  
  70.     private static void sop(Object obj) {  
  71.         System.out.print(obj);  
  72.     }  
  73.   
  74. }  

示例3:对已有文件的数据进行续写

 

 

  1. import java.io.*;  
  2.   
  3. class  FileWriterDemo3 {  
  4.     public static void main(String[] args) {  
  5.           
  6.         try {  
  7.             //传递一个参数,代表不覆盖已有的数据。并在已有数据的末尾进行数据续写  
  8.             FileWriter fw = new FileWriter("F:\\java_Demo\\day9_24\\demo.txt",true);  
  9.             fw.write(" is charactor table?");  
  10.             fw.close();  
  11.         }  
  12.         catch (IOException e) {  
  13.             sop(e.toString());  
  14.         }  
  15.           
  16.     }  
  17.   
  18. /**********************Println************************/  
  19.     private static void sop(Object obj)  
  20.     {  
  21.         System.out.println(obj);  
  22.     }  
  23. }  



练习:

将F盘的一个文件复制到E盘。 

思考:

其实就是将F盘下的文件数据存储到D盘的一个文件中。

步骤:

1.在D盘创建一个文件,存储F盘中文件的数据。
2.定义读取流和F:盘文件关联。
3.通过不断读写完成数据存储。
4.关闭资源。

源码:

  1. import java.io.*;  
  2. import java.util.Scanner;  
  3.   
  4. class CopyText {  
  5.     public static void main(String[] args) throws IOException {  
  6.         sop("请输入要拷贝的文件的路径:");  
  7.         Scanner in = new Scanner(System.in);  
  8.         String source = in.next();  
  9.         sop("请输入需要拷贝到那个位置的路径以及生成的文件名:");  
  10.         String destination = in.next();  
  11.         in.close();  
  12.         CopyTextDemo(source,destination);  
  13.   
  14.     }  
  15.   
  16. /*****************文件Copy*********************/  
  17.     private static void CopyTextDemo(String source,String destination) {  
  18.   
  19.         try {  
  20.             FileWriter fw = new FileWriter(destination);  
  21.             FileReader fr = new FileReader(source);  
  22.             char []  buf = new char[1024];   
  23.             //将Denmo中的文件读取到buf数组中。  
  24.             int num = 0;      
  25.             while((num = fr.read(buf))!=-1) {  
  26.                                //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符  
  27.                 fw.write(new String(buf,0,num));  
  28.             }  
  29.             fr.close();  
  30.             fw.close();  
  31.         }  
  32.         catch (IOException e) {  
  33.             sop(e.toString());  
  34.         }  
  35.     }  
  36.   
  37.   
  38.   
  39. /**********************Println************************/  
  40.     private static void sop(Object obj) {  
  41.         System.out.println(obj);  
  42.     }  
  43. }  

三、缓冲区

1. 字符流的缓冲区:BufferedReader和BufferedWreiter

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

* 需要被提高效率的流作为参数传递给缓冲区的构造函数

* 在缓冲区中封装了一个数组,存入数据后一次取出

BufferedReader示例:

读取流缓冲区提供了一个一次读一行的方法readline,方便对文本数据的获取。
readline()只返回回车符前面的字符,不返回回车符。如果是复制的话,必须加入newLine(),写入回车符

newLine()是java提供的多平台换行符写入方法。

 

  1. import java.io.*;  
  2.   
  3.   
  4. class BufferedReaderDemo {  
  5.     public static void main(String[] args)  throws IOException {  
  6.   
  7.         //创建一个字符读取流流对象,和文件关联  
  8.         FileReader rw = new FileReader("buf.txt");  
  9.   
  10.         //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可  
  11.         BufferedReader brw = new BufferedReader(rw);  
  12.   
  13.           
  14.         for(;;) {  
  15.             String s = brw.readLine();  
  16.             if(s==null) break;  
  17.             System.out.println(s);  
  18.         }  
  19.           
  20.         brw.close();//关闭输入流对象  
  21.   
  22.     }  
  23. }  

 

BufferedWriter示例:

 

  1. import java.io.*;  
  2.   
  3.   
  4. class BufferedWriterDemo {  
  5.     public static void main(String[] args)  throws IOException {  
  6.   
  7.         //创建一个字符写入流对象  
  8.         FileWriter fw = new FileWriter("buf.txt");  
  9.   
  10.         //为了提高字符写入效率,加入了缓冲技术。  
  11.         //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可  
  12.         BufferedWriter bfw = new BufferedWriter(fw);  
  13.   
  14.         //bfw.write("abc\r\nde");  
  15.         //bfw.newLine();               这行代码等价于bfw.write("\r\n"),相当于一个跨平台的换行符  
  16.         //用到缓冲区就必须要刷新  
  17.         for(int x = 1; x < 5; x++) {  
  18.             bfw.write("abc");  
  19.             bfw.newLine();                  //java提供了一个跨平台的换行符newLine();  
  20.             bfw.flush();  
  21.         }  
  22.   
  23.   
  24.   
  25.         bfw.flush();                                                //刷新缓冲区  
  26.         bfw.close();                                                //关闭缓冲区,但是必须要先刷新  
  27.   
  28.         //注意,关闭缓冲区就是在关闭缓冲中的流对象  
  29.         fw.close();                                                 //关闭输入流对象  
  30.   
  31.     }  
  32. }  

2.装饰设计模式

装饰设计模式::::

要求:自定义一些Reader类,读取不同的数据(装饰和继承的区别)
MyReader //专门用于读取数据的类
    |--MyTextReader
        |--MyBufferTextReader
    |--MyMediaReader
        |--MyBufferMediaReader
    |--MyDataReader
        |--MyBufferDataReader

如果将他们抽取出来,设计一个MyBufferReader,可以根据传入的类型进行增强
class MyBufferReader {

    MyBufferReader (MyTextReader text) {}
    MyBufferReader (MyMediaReader media) {}
    MyBufferReader (MyDataReader data) {}
}

但是上面的类拓展性很差。找到其参数的共同类型,通过多态的形式,可以提高拓展性

class MyBufferReader  extends MyReader{
    private MyReader r;                        //从继承变为了组成模式  装饰设计模式
    MyBufferReader(MyReader r) {}
}

优化后的体系:
    |--MyTextReader
    |--MyMediaReader
    |--MyDataReader
    |--MyBufferReader        //增强上面三个。装饰模式比继承灵活,
                              避免继承体系的臃肿。降低类与类之间的耦合性

装饰类只能增强已有的对象,具备的功能是相同的。所以装饰类和被装饰类属于同一个体系

 

 

MyBuffereReader类:  自己写一个MyBuffereReader类,功能与BuffereReader相同

 

    1. class MyBufferedReader1  extends Reader{               
    2.     private Reader r;  
    3.     MyBufferedReader1(Reader r){  
    4.         this.r  = r;  
    5.     }  
    6.   
    7.     //一次读一行数据的方法  
    8.     public String myReaderline()  throws IOException {  
    9.         //定义一个临时容器,原BufferReader封装的是字符数组。  
    10.         //为了演示方便。定义一个StringBuilder容器。最终要将数据变成字符串  
    11.         StringBuilder sb = new StringBuilder();  
    12.         int ch = 0;  
    13.         while((ch = r.read()) != -1)  
    14.         {  
    15.             if(ch == ‘\r‘)   
    16.                 continue;  
    17.             if(ch == ‘\n‘)                    //遇到换行符\n,返回字符串  
    18.                 return sb.toString();  
    19.             else  
    20.             sb.append((char)ch);  
    21.         }  
    22.         if(sb.length()!=0)                    //当最后一行不是以\n结束时候,这里需要判断  
    23.             return sb.toString();  
    24.         return null;  
    25.     }  
    26.     /* 
    27.     需要覆盖Reader中的抽象方法close(),read(); 
    28.     */  
    29.     public void close()throws IOException {  
    30.         r.close();  
    31.     }  
    32.   
    33.     public int read(char[] cbuf,int off, int len)throws IOException {   //覆盖read方法  
    34.         return r.read(cbuf,off,len);  
    35.     }  
    36.   
    37.     public void myClose() throws IOException{  
    38.         r.close();  
    39.     }  
    40.   
    41.   

以上是关于IO流上:概述字符流缓冲区的主要内容,如果未能解决你的问题,请参考以下文章

Java IO流详解——缓冲流

java的 IO流之缓冲流(转载)

十四IO

Java IO流 - 缓冲流的详细使用介绍

Java IO流 - 缓冲流的详细使用介绍

15IO (转换流缓冲流)