BufferWriter 效率高在哪里

菜鸟请教
BufferReader  中有一个readLine() 这个可以直接读取一行数据 从而提高效率 这个清楚了

请教 BufferWriter 只比Writer方法多了一个newLine() 的方法 别貌似都跟Writer方法都一样 不晓得提高效率反映在哪?

如果说  BufferWriter 是先把数据写入缓冲区 flush() 后一次性写入硬盘的方法来来提高效率
那貌似 Writer 也是先把数据写入流 在flush() 或者close() 刷新后才写入硬盘的  这么说来貌似Writer 也有缓冲的能力。

再有BufferWriter  缓冲区有多大 ,如果一个很大分文件要写入 而不再中间进行flush()   缓冲区会不会满 ,如果满了是不是自动写入硬盘?

还有 BufferOutputStream 有是怎么提高OutputStream的效率的  ?

回答

BufferedWriter/BufferedReader 说他效率高是因为他在单纯的读取和输出上加了一个临时存储数据的数组
在用的时候他会根据缓冲区中的缓冲数组大小读取数据到这个数组里然后在对数组进行操作
这里就是他提高效率的地方 有了这数组之后他不会再一次一次的用IO去读
而是直接拿数组的

 

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();//关闭此流,再关闭前会先刷新他。

  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. }  
package Buffered;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterDemo {
	public static void main(String[] args) throws IOException {
		FileWriter fw = new FileWriter("Buffered.txt");
//		fw.write("ok168");
//		fw.close();
		/**
		 * 为了提高写入的效率,使用了字符流的缓冲区。
		 * 创建了一个字符写入流的缓冲区对象,并和指定要被缓冲的流对象相关联。
		 */
		BufferedWriter bufw = new BufferedWriter(fw);
		
		//使用缓冲区中的方法将数据写入到缓冲区中。
		bufw.write("hello world !");
		bufw.newLine();
		bufw.newLine();
		bufw.write("!hello world !");
		bufw.write("!hello world !");
		//使用缓冲区中的方法,将数据刷新到目的地文件中去。
		bufw.flush();
		//关闭缓冲区,同时关闭了fw流对象
		bufw.close();	
	}
}


二、BufferedReader类。

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

主要方法:int read();//读取单个字符。

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

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

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

  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. }  
package Buffered;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterDemo {
	public static void main(String[] args) throws IOException {
		FileWriter fw = new FileWriter("Buffered.txt");
//		fw.write("ok168");
//		fw.close();
		/**
		 * 为了提高写入的效率,使用了字符流的缓冲区。
		 * 创建了一个字符写入流的缓冲区对象,并和指定要被缓冲的流对象相关联。
		 */
		BufferedWriter bufw = new BufferedWriter(fw);
		
		//使用缓冲区中的方法将数据写入到缓冲区中。
		bufw.write("hello world !");
		bufw.newLine();
		bufw.newLine();
		bufw.write("!hello world !");
		bufw.write("!hello world !");
		//使用缓冲区中的方法,将数据刷新到目的地文件中去。
		bufw.flush();
		//关闭缓冲区,同时关闭了fw流对象
		bufw.close();	
	}
}

自定义的一个myBufferedReader类。

  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. }  
package Buffered;

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

public class MyBufferedReader {
	
	private FileReader fr;
	private char []buf = new char[1024];
	private int count = 0;
	private int pos = 0;
	public MyBufferedReader(FileReader f){
		this.fr = f;		
	}
	public int myRead() throws IOException{
		if(count == 0){
			count = fr.read(buf);
			pos = 0;
		}
		if(count<0)
			return -1;
		int ch = buf[pos++];
		count--;
		return ch; 
	}
	
	public String myReadLine() throws IOException{
		StringBuilder sb = new StringBuilder();
		int ch = 0;
		while ((ch = myRead()) != -1) {
			if (ch == '\r')
				continue;
			if (ch == '\n')
				return sb.toString();
			sb.append((char) ch);
			if(count == 0)
				return sb.toString();			
		}
		return null;
	}
	public void myClose() throws IOException {
		fr.close();
	}
}

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

  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. }  

 

阅读更多

PrintWriter和BufferWriter

07-27

[code=Java]rn//服务器rnimport java.net.*;rnimport java.io.*;rnrnpublic class TcpServer rn public static void main(String[] args) throws Exceptionrn ServerSocket server = new ServerSocket (6666);rn Socket client = null;rn while(true) rn client = server.accept();rn System.out.println(" a client has connnected !");rn //获得服务器的输入流rn InputStream serverIs = client.getInputStream();rn BufferedReader serverBr = new BufferedReader(new InputStreamReader(serverIs));rn //获得服务器的输出流rn OutputStream serverOs = client.getOutputStream();rn PrintWriter serverBw = new PrintWriter(new OutputStreamWriter(serverOs));rn serverBw.println("welcome !");rn serverBw.flush();rn System.out.print("client :");rn System.out.println(serverBr.readLine());rn System.out.print("server :");rn //获得命令行的输入的字符,并将其送到服务器的输出流上rn BufferedReader br = new BufferedReader(new InputStreamReader(System.in));rn String words = null;rn words = br.readLine();rn while(!words.equals("exit")) rn serverBw.println(words);rn serverBw.flush();rn System.out.print("client :");rn System.out.println(serverBr.readLine());rn System.out.print("server :");rn rn serverBw.close();rn br.close();rn serverBr.close();rn rn rnrnrn//客户端rnimport java.net.*;rnimport java.io.*;rnrnpublic class TcpClient rn public static void main(String[] args) throws Exceptionrn Socket client = new Socket("127.0.0.1",6666);rn //获得客户端的输入流rn BufferedReader clientBr = new BufferedReader(new InputStreamReader(client.getInputStream()));rn //获得客户端的输出流rn PrintWriter clientBw = new PrintWriter(new OutputStreamWriter(client.getOutputStream()));rn System.out.println("server :" + clientBr.readLine());rn System.out.print("client :");rn //获得命令行的输入流,并将其送到客户端的输出流上rn BufferedReader br = new BufferedReader(new InputStreamReader(System.in));rn String words = br.readLine();rn while(! words.equals("exit"))rn clientBw.println(words);rn clientBw.flush();rn System.out.println("server :" + clientBr.readLine());rn System.out.print("client :");rn rn clientBw.close();rn clientBr.close();rn br.close();rn client.close();rn rnrn[/code]rn问题是:将程序中的PrintWriter流改成BufferWriter流,程序就阻塞在那了,这是为什么

没有更多推荐了,返回首页