Java :BufferedWriter类和BufferedReader类的构造方法、主要方法

BufferedWriter 和 BufferedReader 为带有默认缓冲的字符输出输入流,因为有缓冲区所以效率比没有缓冲区的高。

一、BufferedWriter 类

构造方法:bufferedWriter bf = new bufferedWriter(Writer out );

主要方法:void write(char ch);//写入单个字符。

                  void write(char []cbuf,int off,int len)//写入字符数据的某一部分。

                  void write(String s,int off,int len)//写入字符串的某一部分。

                  void newLine()//写入一个行分隔符。

                  void flush();//刷新该流中的缓冲。将缓冲数据写到目的文件中去。

                  void close();//关闭此流,再关闭前会先刷新他。

[java]  view plain  copy
  1. package Buffered;  
  2.   
  3. import java.io.BufferedWriter;  
  4. import java.io.FileWriter;  
  5. import java.io.IOException;  
  6.   
  7. public class BufferedWriterDemo {  
  8.     public static void main(String[] args) throws IOException {  
  9.         FileWriter fw = new FileWriter("Buffered.txt");  
  10. //      fw.write("ok168");  
  11. //      fw.close();  
  12.         /** 
  13.          * 为了提高写入的效率,使用了字符流的缓冲区。 
  14.          * 创建了一个字符写入流的缓冲区对象,并和指定要被缓冲的流对象相关联。 
  15.          */  
  16.         BufferedWriter bufw = new BufferedWriter(fw);  
  17.           
  18.         //使用缓冲区中的方法将数据写入到缓冲区中。  
  19.         bufw.write("hello world !");  
  20.         bufw.newLine();  
  21.         bufw.newLine();  
  22.         bufw.write("!hello world !");  
  23.         bufw.write("!hello world !");  
  24.         //使用缓冲区中的方法,将数据刷新到目的地文件中去。  
  25.         bufw.flush();  
  26.         //关闭缓冲区,同时关闭了fw流对象  
  27.         bufw.close();     
  28.     }  
  29. }  


二、BufferedReader类。

构造方法:BufferedReader br = new BufferReader(Reader in);

主要方法:

int read();//读取单个字符。

int read(char[] cbuf,int off,int len);//将字符读入到数组的某一部分。返回读取的字符数。达到                                                            尾部 ,返回-1。

String readLine();                        //读取一个文本行。

void close();                                //关闭该流。并释放与该流相关的所有资源。

 

自定义的一个myBufferedReader类。

[java]  view plain  copy
  1. package Buffered;  
  2.   
  3. import java.io.FileReader;  
  4. import java.io.IOException;  
  5.   
  6. public class MyBufferedReader {  
  7.       
  8.     private FileReader fr;  
  9.     private char []buf = new char[1024];  
  10.     private int count = 0;  
  11.     private int pos = 0;  
  12.     public MyBufferedReader(FileReader f){  
  13.         this.fr = f;          
  14.     }  
  15.     public int myRead() throws IOException{  
  16.         if(count == 0){  
  17.             count = fr.read(buf);  
  18.             pos = 0;  
  19.         }  
  20.         if(count<0)  
  21.             return -1;  
  22.         int ch = buf[pos++];  
  23.         count--;  
  24.         return ch;   
  25.     }  
  26.       
  27.     public String myReadLine() throws IOException{  
  28.         StringBuilder sb = new StringBuilder();  
  29.         int ch = 0;  
  30.         while ((ch = myRead()) != -1) {  
  31.             if (ch == '\r')  
  32.                 continue;  
  33.             if (ch == '\n')  
  34.                 return sb.toString();  
  35.             sb.append((char) ch);  
  36.             if(count == 0)  
  37.                 return sb.toString();             
  38.         }  
  39.         return null;  
  40.     }  
  41.     public void myClose() throws IOException {  
  42.         fr.close();  
  43.     }  
  44. }  

 

使用bufferedReader 和bufferWriter方法写的一个复制文本的小程序

[java]  view plain  copy
  1. package IOtest;  
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.BufferedWriter;  
  5. import java.io.FileReader;  
  6. import java.io.FileWriter;  
  7. import java.io.IOException;  
  8.   
  9. public class TextCopyByBuf {  
  10.   
  11.     /** 
  12.      * 首先创建读取字符数据流对象关联所要复制的文件。 
  13.      * 创建缓冲区对象关联流对象。 
  14.      * 从缓冲区中将字符创建并写入到目的文件中。 
  15.      * @throws IOException  
  16.      */  
  17.     public static void main(String[] args) throws IOException {  
  18.         FileReader fr = new FileReader("C:\\demo.txt");  
  19.         FileWriter fw = new FileWriter("D:\\love.txt");  
  20.         BufferedReader bufr = new BufferedReader(fr);  
  21.         BufferedWriter bufw = new BufferedWriter(fw);  
  22.         //一行一行的寫。  
  23.         String line = null;  
  24.         while((line = bufr.readLine()) != null){  
  25.             bufw.write(line);  
  26.             bufw.newLine();  
  27.             bufw.flush();  
  28.         }  
  29.     /*  一個字節一個字節的寫。 
  30.         int ch = 0; 
  31.         while((ch = bufr.read())!=-1){ 
  32.             bufw.write(ch); 
  33.         }*/  
  34.         bufr.close();  
  35.         bufw.close();  
  36.     }  
  37. }  

转载于:https://my.oschina.net/u/3624220/blog/1528632

你可能感兴趣的:(java)