(java)IO流对象（五）缓冲流

最新推荐文章于 2024-01-03 17:37:06 发布

原创最新推荐文章于 2024-01-03 17:37:06 发布 · 242 阅读

0 ·

CC 4.0 BY-SA版权

Java 同时被 2 个专栏收录

43 篇文章

订阅专栏

JavaIO流对象

6 篇文章

订阅专栏

本文深入探讨Java IO流的概念，包括字节流与字符流的缓冲机制，演示了如何利用BufferedInputStream、BufferedOutputStream、BufferedReader和BufferedWriter进行高效文件操作，以及四种文件复制方法的效率对比。

/*
 * 获取方法的内容一般都有返回值 
 *     int类型     若没有了，返回的都是负数
 *     引用类型      若没有了，返回的是null
 *     boolean   若没有了，返回的都是false
 */

【字节缓冲流】

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/* A.字节输出流的缓冲流：
 *    java.io.BufferedOutputStream   继承了OutputStream
 *          作用：提高原有输出流的写入效率
 *          方法：write()   参数：单个字节、字节数组
 *    构造方法：BufferedOutputStream(OutputStream out)  可以高效率传递任意的字节输出流  如 FileOutputStream
 */
/* B.字节输入流的缓冲流：
 *    java.io.BufferedInputStream   继承了InputStream
 *          作用：提高原有输入流的读取效率
 *          方法：read()   参数：单个字节、字节数组
 *    构造方法：BufferedInputStream(InputStream in)  可以高效率传递任意的字节输入流  如 FileInputStream
 */
public class BufferedDemo1 {
	public static void main(String[] args) throws IOException{
		function_2();
	}
	
	// A. 字节输出流的缓冲流 BufferedOutputStream
	public static void function_1() throws IOException{
		// 创建字节输出流对象,绑定文件
		FileOutputStream fos = new FileOutputStream("E:\\workspace\\Demo\\Buffer_out.txt");
		// 创建字节输出流缓冲流对象，构造方法中 传递字节输出流
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		
		bos.write(55);
		
		byte[] bytes = "Hello".getBytes();
	    bos.write(bytes);
	    bos.write(bytes,0,5);               
	    
		bos.close();                      // 写入文件中的内容：7HelloHello
	}
	
	// B. 字节输入流的缓冲流 BufferedInputStream 
	public static void function_2() throws IOException{
		// 创建字节输入流对象，
		FileInputStream fis = new FileInputStream("E:\\workspace\\Demo\\Buffer_out.txt");
		// 创建字节输入流缓冲流对象，构造方法中 传递字节输入流
		BufferedInputStream bis = new BufferedInputStream(fis);
		
		byte[] bytes = new byte[20];
		int len = 0;
		while((len = bis.read(bytes)) != -1){
			System.out.println(new String(bytes, 0, len));
		}
		
		bis.close();                    // 读取到的文件  7HelloHello
	}

}

【字节流 -- 四种文件复制方式】

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 *  文件复制方式：使用字节流，一共四种方式
 *      1. 字节流读写取单个字节                   需要249 mm
 *      2. 字节流读写字节数组                       需要 75 mm
 *      3. 字节流缓冲区流读写单个字节       需要   3  mm
 *      4. 字节流缓冲区流读写字节数组       需要   1  mm
 * 
 */
public class CopyDemo1 {
	public static void main(String[] args) throws IOException {
		
		// 统计方法运行的时间  单位：毫秒
		long s = System.currentTimeMillis();
		
		copy_4(new File("E:\\workspace\\Demo\\Copy_src.png"), 
				new File("E:\\workspace\\Demo\\Copy_desc.png"));
		
		long e = System.currentTimeMillis();
		System.out.println(e-s);  
	}
	
	// 1.复制文件 ---- 使用字节流读写取单个字节byte    需要249mm
	public static void copy_1(File src, File desc) throws IOException{
		FileInputStream fis = new FileInputStream(src);
		FileOutputStream fos = new FileOutputStream(desc) ;
		
		int len = 0;
		while((len =fis.read()) != -1){
			fos.write(len);
		}
		
		// 关闭系统资源
		fos.close();
		fis.close();
	}
	
	// 2.复制文件 ---- 使用字节流读写字节数组byte[]    需要 75 mm
	public static void copy_2(File src, File desc) throws IOException{
		FileInputStream fis = new FileInputStream(src);
		FileOutputStream fos = new FileOutputStream(desc) ;
		
		byte[] bytes = new byte[1024];
		int len = 0;
		while((len = fis.read(bytes)) != -1){
			fos.write(bytes,0,len);
		}
		
		// 关闭系统资源
		fos.close();
		fis.close();
	}
	
	// 3.复制文件 ---- 字节流缓冲区流读写单个字节byte    需要 3 mm
	public static void copy_3(File src, File desc) throws IOException{
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
		
		int len = 0;
		while((len =bis.read()) != -1){
			bos.write(len);
		}
		
		// 关闭系统资源
		bos.close();
		bis.close();	
			
	}
	
	// 4.复制文件 ---- 字节流缓冲区流读写字节数组byte[]    需要 1 mm
	public static void copy_4(File src, File desc) throws IOException{
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
		
		byte[] bytes = new byte[1024];
		int len = 0;
		while((len = bis.read(bytes)) != -1){
			bos.write(bytes,0,len);
		}
		
		// 关闭系统资源
		bos.close();
		bis.close();
	}
}

【字符缓冲流】

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
 *   A. 字符输出流缓冲区流   :
 *       java.io.BufferedWriter  继承Writer
 *           作用：提高原有输出流的写入效率
 *           方法：              write()          参数：单个字符char、字符数组char[]、字符串 String
 *           特有的方法 ：void newLine()   写换行         此方法具有平台无关性
 *                    windows  换行\r\n    Linux   换行  \n 
 *       构造方法：
 *           BufferedWriter(Write w)  传递任意字符输出流     FileWriter、  OutputStreamWriter       
 */
/*
 *   B. 字符输入流缓冲区流   :
 *        java.io.BufferedReader   继承Reader
 *           作用：提高原有输出流的写入效率
 *           方法：         read()             参数： 单个字符char，字符数组char[]
 *           特有方法： String readLine()  读取文本行     方法返回的有效字符没有\r\n
 *        构造方法：
 *           BufferedReader(Reader r) 传递任意字符输入流    FileReader、InputStreamReader
 * 
 */
public class BufferedDemo2 {
	public static void main(String[] args) throws IOException {
		function_2();
	}
	
	// A. 字符输出流缓冲区流   
	public static void function_1() throws IOException{
		// 创建字符输出流，封装文件
		FileWriter fw = new FileWriter("E:\\workspace\\Demo\\Buffer_out2.txt");
		BufferedWriter bw = new BufferedWriter(fw);
				
		bw.write(110);
		bw.newLine();                    // 换行
		bw.flush();    
			
		bw.write("嘻哈".toCharArray());   // 把一个字符串变  为   字符数组
		bw.flush();
				
		bw.write("呵呵");
		bw.flush();
				
		bw.close();                      // 写入文本中的内容：  n嘻哈呵呵
	}
	
	// B. 字符输入流缓冲区流
	public static void function_2() throws IOException{
		// 创建输入流字符缓冲区流对象，构造方法中传递字符输入流，包装数据源文件
		BufferedReader br = new BufferedReader(new FileReader("E:\\workspace\\Demo\\Buffer_out3.txt"));
		
		// 行号变量
		int lineNumber = 0;
		String line = null;
		// 循环读取文本行，结束条件readLine()返回null
		while((line = br.readLine()) != null){
			lineNumber++;
			System.out.println(lineNumber+" "+line);  
			//System.out.print(line+"\r\n");     //  同上
			
		}
		
		/*
		String line  = br.readLine();
		System.out.println(line);               //  line1: 只有睿智的河水知道
		
		line  = br.readLine();
		System.out.println(line);              //   line2: 白雪是因为贪玩跑出了城堡
		
	    line  = br.readLine();
		System.out.println(line);              //   line3: null
		 
		br.close();                            //   文件中只有两行文字             
		*/     
	}

}

【字符流缓冲区流复制文件】

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

/*
 *  字符流缓冲区流复制文件：
 *      数据源  BufferedReader + FileReader  读取
 *      数据目的  BufferedWriter + FileWriter 写入
 *  读取文本，读一行，写一行
 */
public class CopyDemo2 {
	public static void main(String[] args) throws IOException {
		// 创建字符输入流缓冲区流对象，构造方法中传递字符输入流，绑定数据源
		BufferedReader br = new BufferedReader(new FileReader("E:\\workspace\\Demo\\Buffer_out3.txt"));
		// 创建字符输出流缓冲区流对象，构造方法中传递字符输出流，绑定数据目的
		BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\workspace\\Demo\\Buffer_out3_copy.txt"));
		
		String line = null;
		 while((line = br.readLine()) != null){
			 bw.write(line);
			 bw.newLine(); // 换行
			 bw.flush();   // 更新
		 }
		 
		// 关闭资源
		bw.close();
		br.close();
	}

}