Java专题 IO字节流，高效缓冲流总结 +拷贝文件多情况案例详解

IO字节流

单个读入及解释

	// IO字节流 操作
	//在操作流对象的时候，要处理解决异常		.io 包
	//在操作完流对象之后，需要关闭资源

	//InputStream   OutputStream是顶层接口
	//初始化 和 构造方法
	File file = new File("xxxx.xxx");
	File file2 = new File("yyy.yyy");
	
	InputStream inputStream = new FileInputStream(file);
	InputStream inputStream1 = new FileInputStream("");	//输入文件类型的路径
	
	OutputStream outputStream = new FileOutputStream("");
	OutputStream outputStream1 = new FileOutputStream(file2);
	
	inputStream.read();				//一次读取一个字节返回值类型是int类型，原因要把返回的
//	字节前面加上24个0，无论读取到的是负数还是整数，都会变成正数，只要是从文件中读取
//	到的数据，都是整数；如果返回了-1，就说明不是从文件中读到的数据，而是整个方法专门准备
//	的文件末尾的标记。说明：虽然每次调用该方法，但是返回的内容却不会相同，因为文件指针在不断
//	向后移动。
	
//	file.read(byte[] arr);   一次读取多个字节，存储到字节数组中
	

循环读入

	//循环读入			输入流  读取方法
	File file3 =new File("a.txt");
	InputStream is = new FileInputStream(file3);
	
	int i;
	while ((i = is.read())!=-1) {
		System.out.println(i);
	}
	
	//outputstream   输出流  写入方法
	File file4 = new File("x.txt");
	OutputStream os = new FileOutputStream(file4);	//默认只写路径 覆盖写入 运行多少次
													//	都只有执行一次的效果
	os.write(i);    		//单个写入
	os.write(byte[] b);		//以字节数组写入
	os.write(b, 0, len);	//以字节数组写入，可确定区间
	
	OutputStream sos = new FileOutputStream(file4,true);	//加 true,写入内容不会覆盖原有内容
															//多次运行会出现多个一样的内容
	
	//关闭资源  输入输出流		正常情况下必须必须必须必须必须必须必须必须必须必须必须要做的事情！
	is.close();
	os.close();

文件拷贝

单个字节读入

	//文件拷贝  单个读入
	File file5 = new File("");                      //文件指定的路径 可以减少下面的路径输入
	InputStream isStream = new FileInputStream(file5);	//要读取的文件路径
	OutputStream osStream = new FileOutputStream("");	//想要写入的文件路径或者目录下
	
	int i1;									//单个字节读入
	while ((i1 = isStream.read())!=-1) {	//没有读到最后就继续
		osStream.write(i1);					//单个字节写入
	}
	
	isStream.close();						//关闭资源！！！！！
	osStream.close();						//关闭资源！！！！！

文件拷贝2 提升读写效率

	//文件拷贝2 拷贝效率提升
	File file6 = new File("");
	InputStream is1 = new FileInputStream(file6);
	OutputStream os1 = new FileOutputStream("");
	
	byte[] bt = new byte[1024*8]; 			//以字节数组读入    一次读入多个字节  一些写入多个字节
	int len;								//可能读不满 8192个字节  这个时候如下操作
	while ((len = is1.read(bt))!=-1) {		//读入返回长度，内容已经读入，只是返回值为长度
		os1.write(bt,0,len);				//读多少写多少				
	}
	
	is1.close();							//关闭资源！！！！！
	os1.close();							//关闭资源！！！！！
	
//	数组的大小可以任意选择，数组越大，拷贝次数越少，拷贝的效率越高
// 	一般情况，数组的大小使用1024的整数倍，在jdk中喜欢使用1024*8大小作为缓冲区的大小。

文件拷贝3 一次读入

	
	//文件拷贝3  一次性方法
	InputStream is2 = new FileInputStream("");
	OutputStream os2 = new FileOutputStream("");
	
	byte[] by2 = new byte[is2.available()];		 //一次性读入文件大小，但是并不是无限大，有界限
	int len2;
	while ((len2 = is2.read(by2))!=-1) {
		os2.write(by2,0,len2);					//只要一次读入多个就可能存在不满的情况 需要分段
	}
	
	is2.close();								//关资源
	os2.close();								//关资源！！！！！！
	

读写方法理解

read()方法返回的是读取的有效字节本身
read(byte[] arr)方法的返回是读取到的有效字节的个数（返回值的取值范围：-1,1~arr.length）

read()读取到的文件字节信息是作为返回值进行返回的
read(byte[] arr)读取到的字节信息，存储到参数数组arr中

高效缓冲流

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(""));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(""));

BufferedInputStream高效的原理：在该类型中准备了一个数组，存储字节信息，当外界调用read()方法想获取一个字节的时候，该对象从文件中一次性读取了8192个字节到数组中，只返回了第一个字节给调用者。将来调用者再次调用read方法时，当前对象就不需要再次访问磁盘，只需要从数组中取出一个字节返回给调用者即可，由于读取的是数组，所以速度非常快。当8192个字节全都读取完成之后，再需要读取一个字节，就得让该对象到文件中读取下一个8192个字节了。

BufferedOutputStream高效的原理：在该类型中准备了一个数组，存储字节信息，当外界调用write方法想写出一个字节的时候，该对象直接将这个字节存储到了自己的数组中，而不刷新到文件中。一直到该数组所有8192个位置全都占满，该对象才把这个数组中的所有 数据一次性写出到目标文件中。如果最后一次循环过程中，没有将数组写满，最终在关闭流对象的时候，也会将该数组中的数据刷新到文件中。

	//高效缓冲  拷贝案例
	BufferedInputStream biStream = new BufferedInputStream(new FileInputStream(""));
	BufferedOutputStream boStream = new BufferedOutputStream(new FileOutputStream(""));
	
	int bi;
	while ((bi = biStream.read())!=-1) {
		boStream.write(bi);
	}
	
	biStream.close();
	boStream.close();	//输出流一定要关  否则最后字段不足8192的部分会放在缓存区而不刷新到文件
	
	//也可以和字节数组一起使用   也会有所提升   一般使用JDK 1024*8

输出流中.close() .flush() 区别

close方法会先调用flush方法
close方法用于流对象的关闭，一旦调用了close方法，那么这个流对象就不能继续使用了
flush只是将缓冲区中的数据，刷新到相应文件中，而不会将流对象关闭，可以继续使用这个流对象。但是如果flush方法使用过于频繁，那么丧失了缓冲区的作用。