IO流之缓冲流

缓冲流

Java中提高了一套缓冲流，它的存在，可提高IO流的读写速度

缓冲流，根据流的分类字节缓冲流与字符缓冲流。

字节缓冲流

字节缓冲流根据流的方向，共有2个

l  写入数据到流中，字节缓冲输出流 BufferedOutputStream

l  读取流中的数据，字节缓冲输入流 BufferedInputStream

 

它们的内部都包含了一个缓冲区，通过缓冲区读写，就可以提高了IO流的读写速度

 字节缓冲输出流BufferedOutputStream

通过字节缓冲流，进行文件的读写操作 写数据到文件的操作 

l  构造方法

public BufferedOutputStream(OutputStream out)创建一个新的缓冲输出流，以将数据写入指定的底层输出流。

 

public class BufferedOutputStreamDemo01 {
	public static void main(String[] args) throws IOException {
		
		//写数据到文件的方法
		write();
	}

	/*
	 * 写数据到文件的方法
	 * 1,创建流
	 * 2，写数据
	 * 3，关闭流
	 */
	private static void write() throws IOException {
		//创建基本的字节输出流
		FileOutputStream fileOut = new FileOutputStream("abc.txt");
		//使用高效的流，把基本的流进行封装，实现速度的提升
		BufferedOutputStream out = new BufferedOutputStream(fileOut);
		//2，写数据
		out.write("hello".getBytes());
		//3，关闭流
		out.close();
	}
}

　

1.1.1     字节缓冲输入流 BufferedInputStream

刚刚我们学习了输出流实现了向文件中写数据的操作，那么，现在我们完成读取文件中数据的操作

l  构造方法

public BufferedInputStream(InputStream in)

 

/*
	 * 从文件中读取数据
	 * 1,创建缓冲流对象
	 * 2，读数据，打印
	 * 3，关闭
	 */
	private static void read() throws IOException {
		//1,创建缓冲流对象
		FileInputStream fileIn = new FileInputStream("abc.txt");
		//把基本的流包装成高效的流
		BufferedInputStream in = new BufferedInputStream(fileIn);
		//2，读数据
		int ch = -1;
		while ( (ch = in.read()) != -1 ) {
			//打印
			System.out.print((char)ch);
		}
		//3，关闭
		in.close();
	}

使用基本的流与高效的流完成复制文件

我们一直在说，高效的流速度快并高效，怎么体现呢？需要通过一个复制文件耗时的比较过程，来体验一下高效流带来的快感。

/*
 * 需求：将d:\\test.avi文件进行复制
 * 		采用4种方式复制
 * 		方式1： 采用基本的流，一次一个字节的方式复制	共耗时 224613毫秒
 * 		方式2： 采用基本的流，一个多个字节的方式赋值	共耗时     327毫秒
 * 		方式3： 采用高效的流，一次一个字节的方式复制	共耗时    2047毫秒
 * 		方式4： 采用高效的流，一个多个字节的方式赋值	共耗时      96毫秒
 * 
 * 数据源： d:\\test.avi
 * 目的地1: d:\\copy1.avi
 * 目的地2: d:\\copy2.avi
 * 目的地3: d:\\copy3.avi
 * 目的地4: d:\\copy4.avi
 * 
 * 实现的步骤：
 * 	1，指定数据源
 * 	2，指定目的地
 * 	3，读数据
 * 	4，写数据
 * 	5，关闭流
 * 
 */
public class CopyAVI {
	public static void main(String[] args) throws IOException {
		//开始计时
		long start = System.currentTimeMillis();
		//方式1： 采用基本的流，一次一个字节的方式复制
		//method1("d:\\test.avi", "d:\\copy1.avi");
		//方式2： 采用基本的流，一个多个字节的方式赋值
		//method2("d:\\test.avi", "d:\\copy2.avi");
		//方式3： 采用高效的流，一次一个字节的方式复制
		//method3("d:\\test.avi", "d:\\copy3.avi");
		//方式4： 采用高效的流，一个多个字节的方式赋值
		method4("d:\\test.avi", "d:\\copy4.avi");
		
		//结束计时
		long end = System.currentTimeMillis();
		//打印耗时多少毫秒
		System.out.println("共耗时 " +(end - start)+ "毫秒");
	}
	
	//方式4： 采用高效的流，一个多个字节的方式赋值
	private static void method4(String src, String dest) throws IOException {
		//1，指定数据源
		BufferedInputStream in = new BufferedInputStream(new FileInputStream(src));
		 //2，指定目的地
		BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest));
		 //3，读数据
		byte[] buffer = new byte[1024];
		int len = -1;
		while ( (len = in.read(buffer)) != -1) {
			//4,写数据
			out.write(buffer, 0, le n);
		}
		 //5，关闭流
		in.close();
		out.close();
	}

	//方式3： 采用高效的流，一次一个字节的方式复制
	private static void method3(String src, String dest) throws IOException {
		//1，指定数据源
		BufferedInputStream in = new BufferedInputStream(new FileInputStream(src));
		 //2，指定目的地
		BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest));
		 //3，读数据
		int ch = -1;
		while ((ch=in.read()) != -1) {
			//4，写数据
			out.write(ch);	
		}		
		 //5，关闭流
		in.close();
		out.close();
	}

	//方式2： 采用基本的流，一个多个字节的方式赋值
	private static void method2(String src, String dest) throws IOException {
		//1，指定数据源
		FileInputStream in = new FileInputStream(src);
		//2，指定目的地
		FileOutputStream out = new FileOutputStream(dest);
		//3，读数据
		byte[] buffer = new byte[1024];
		int len = -1;
		while ( (len=in.read(buffer)) != -1) {
			//4，写数据
			out.write(buffer, 0, len);
		}
		//5，关闭流
		in.close();
		out.close();
	}

	//方式1： 采用基本的流，一次一个字节的方式复制
	private static void method1(String src, String dest) throws IOException {
		//1，指定数据源
		FileInputStream in = new FileInputStream(src);
		//2，指定目的地
		FileOutputStream out = new FileOutputStream(dest);
		//3，读数据
		int ch = -1;
		while (( ch=in.read()) != -1) {
			//4，写数据
			out.write(ch);
		}
		//5，关闭流
		in.close();
		out.close();
	}
}

　

字符缓冲流

l  字符缓冲输入流 BufferedReader

l  字符缓冲输出流 BufferedWriter

完成文本数据的高效的写入与读取的操作

字符缓冲输出流 BufferedWriter

将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

l  方法：

void newLine() 根据当前的系统，写入一个换行符

/*
 * BufferedWriter 字符缓冲输出流
 * 方法
 * 	public void newLine()写入一个行分隔符
 * 
 * 需求： 通过缓冲输出流写入数据到文件
 * 分析：
 * 	1，创建流对象
 * 	2，写数据
 * 	3，关闭流
 * 
 */
public class BufferedWriterDemo {
	public static void main(String[] args) throws IOException {
		//创建流
		//基本字符输出流
		FileWriter fileOut = new FileWriter("file.txt");
		//把基本的流进行包装
		BufferedWriter out = new BufferedWriter(fileOut);
		//2，写数据
		for (int i=0; i<5; i++) {
			out.write("hello");
			out.newLine();
		}
		//3,关闭流
		out.close();
	}
}

  字符缓冲输入流 BufferedReader

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

l  方法

public String readLine() 读取一个文本行，包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

/*
 * BufferedReader 字符缓冲输入流
 * 
 * 方法：
 * 	String readLine() 
 * 需求：从文件中读取数据，并显示数据
 */
public class BufferedReaderDemo {
	public static void main(String[] args) throws IOException {
		//1,创建流
		BufferedReader in = new BufferedReader(new FileReader("file.txt"));
		//2，读数据
		//一次一个字符
		//一次一个字符数组
		//一次读取文本中一行的字符串内容
		String line = null;
		while( (line = in.readLine()) != null ){
			System.out.println(line);
		}
		
		//3,关闭流
		in.close();
	}
}

使用字符缓冲流完成文本文件的复制

/*
 * 采用高效的字符缓冲流，完成文本文件的赋值
 * 
 * 数据源： file.txt
 * 目的地： copyFile.txt
 * 
 * 分析：
 * 	1，指定数据源， 是数据源中读数据，采用输入流
 * 	2,指定目的地，是把数据写入目的地，采用输出流
 * 	3,读数据
 * 	4，写数据
 * 	5，关闭流
 */
public class CopyTextFile {
	public static void main(String[] args) throws IOException {
		//1，指定数据源， 是数据源中读数据，采用输入流
		BufferedReader in = new BufferedReader(new FileReader("file.txt"));
		//2,指定目的地，是把数据写入目的地，采用输出流
		BufferedWriter out = new BufferedWriter(new FileWriter("copyFile.txt"));
		//3,读数据
		String line = null;
		while ( (line = in.readLine()) != null ) {
			//4，写数据
			out.write(line);
			//写入换行符号
			out.newLine();
Out.flush();
		}
		//5，关闭流
		out.close();
		in.close();
	}
}