Java IO (四)之常用节点流及练习2

字节数组引入：

1. 此时将源头换成内存（字节数组），可以看成是电脑上的一块内存、网络上的一块内存、远程服务器上的一块内存
2. JVM可以直接访问内存，因此使用的资源是有垃圾回收器进行时放，因此不用我们手动关闭

字节数组流

要知道的：

• 所有的东西都可以转换成字节数组（例如：字符串、对象、…）；
• 由于字节数组是二进制形式因而更方便进行网络的传输。
• 字节数组的大小不要设置太大

主要区别：

1. 创建的源都是：字节数组
2. 不需要关闭流

字节数组输入流ByteArrayInputStream

package com.sxt.IO;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 1.创建源：（byte[]）“不同点1”
 * 2.选择流（字节输入流：InputStream）
 * 3.操作
 * 4.关闭：可以省略	“不同点2”
 * @描述：字节数组输入流
 * 操作工具：标尺、小车（byte[]）
 *特点：选择流的不同、小车是byte[]、不需要关闭流
 */
public class ByteArrayIo {
	public static void main(String[] args) {
		//1.创建源
		byte[] src = "Talk is cheap , Just show me your code!".getBytes();
		//2.选择流
		InputStream in = new ByteArrayInputStream(src);
		//3.操作
		//3.1标尺
		int len;
		//3.2小车
		byte[] flush = new byte[2];
		try {
			while((len = in.read(flush)) != -1){
				//打包输出：字节数组-->字符串（解码）
				String s = new String(flush,0,len);
				System.out.println(s);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

字节数组输出流ByteArrayOutputStream

package com.sxt.IO;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

/**
 * 1.创建源:源头内部来维护(不需要目的源文件)	“不同点1”
 * 2.选择流：ByteArrayOutputStream(不关联源即由于使用的是子类新增的方法因此不能使用多态)	“不同点2”
 * 3.操作：写出内容	“不同点3”
 * 	3.1获取数据：byteArrayIO.toByteArray();
 * 4.关闭：可以省略	“不同点4” 
 * @描述：字节数组输出流
 * 操作工具：小车、要写出的数据
 */
public class ByteArrayIo_writer {
	public static void main(String[] args) {
		//1.创建源
		byte[] dest = null;
		//2.选择流
		ByteArrayOutputStream byteArrayIO = new ByteArrayOutputStream();
		//3.操作
		//3.1准备工具
		String s = "Show me your code!";//数据
		byte[] flush = s.getBytes();//小车
		//3.2数据的写出
		try {
			byteArrayIO.write(flush);
			//3.3 flush操作
			byteArrayIO.flush();
			//3.4获取数据
			dest = byteArrayIO.toByteArray();
			System.out.println(dest.length+"---->"+
			new String(dest,0,byteArrayIO.size()));
		} catch (IOException e) {
			e.printStackTrace();
		}		
	}
}

对接流

package io;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 1、图片---字节数组
 * 	1.1、图片--程序
 * 	1.2、程序--字节数组
 * 2、字节数组---图片
 * 	2.1、字节数组--程序
 * 	2.1、程序--图片
 * @描述：对接流
 */
public class ComprehensiveIO {
	public static void main(String[] args) {
		//1、图片--字节数组
		byte[] src = fileToByteArray("src/images/p1.jpg");
		//2、字节数组--图片
		byteArrayToFile(src,"src/images/copy_p1.jpg");
		
	}
	/**
	 * 过程：图片（文件）--程序--字节数组
	 *@描述：将图片转换成字节数组的形式
	 * @param 图片被转换成的字节数组
	 * @return
	 */
	private static byte[] fileToByteArray(String path) {
		//FileInPutStream ---> byteArrayOutputStream
		//1、创建源
		File srcFile = new File(path);
		byte[] desFile = null;
		//2、选择流
		InputStream in = null;
		try {
			in = new FileInputStream(srcFile);
			ByteArrayOutputStream out = new ByteArrayOutputStream();
			//3、数据的读取
			int len;
			byte[] flush = new byte[1024];
			try {
				while((len = in.read(flush))!= -1){
					//3.1、整理数据并输出(注意这里write写出的范围是“0--len”)
					out.write(flush,0,len);
					out.flush();
					desFile = out.toByteArray();
				}
				return desFile;
			} catch (IOException e) {
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			
			e.printStackTrace();
		}finally{
			if(in != null){
				try {
					in.close();
				} catch (IOException e) {
					
					e.printStackTrace();
				}
			}
		}return null;
	}
	/**
	 * 过程：字节数组--程序--图片（文件）
	 *@描述：将字节数组中的图片（byte类型）还原成图片（.jpg）的形式
	 * @param src 要还原的源文件
	 * @param string 还原后要保存的图片
	 */
	private static void byteArrayToFile(byte[] src, String path) {
		//byteArrayInputStream --> FileOutputStream
		//1、创建目的源
		File file = new File(path);
		//2、选择流
		InputStream in = null;
		OutputStream out = null;
		in = new ByteArrayInputStream(src);
		try {
			out = new FileOutputStream(file);
		} catch (FileNotFoundException e1) {
			e1.printStackTrace();
		}
		//3、对数据进行操作
		int len;
		byte[] flush = new byte[1024];
		try {
			while((len=in.read(flush))!= -1){
				out.write(flush,0,len);
				out.flush();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(out != null){
				try {
					out.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

综合应用：工具类的使用

引入：由上面的学习可以知道抽象类：InputStream、OutputStream下的具体实现类的存储数据的方式都是样的：标尺、小车、判断是否有数据可读、数据的写出操作；因此这些都可以封装成一个方法便于代码的管理。

1. InptuStream抽象类下主要的具体实现类：FileInputStream、ByteArrayInputStream
2. OutputStream抽象类下的主要的具体实现类：FileOutputStream、ByteArrayOutputStream

package com.sxt.IO;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class FileUtils {

	/**
	 * 1、字节数据的封装拷贝
	 * 2、封装释放资源
	 * 3、try ... with ... resource
	 *@描述：
	 * @param args
	 */
	public static void main(String[] args) {
		//1.1、字节文件与字节文件之间的拷贝
		try {
			InputStream in = new FileInputStream("src2/com/sxt/IO/test.txt");
			OutputStream out = new FileOutputStream("src2/com/sxt/IO/test_copy.txt");
			copy(in,out);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		
		//1.2、字节文件到字节数组之间的拷贝
		byte[] datas = null;
		try {
			InputStream in = new FileInputStream("src2/com/sxt/IO/images/p1.jpg");
			ByteArrayOutputStream out = new ByteArrayOutputStream();
			copy(in,out);
			datas = out.toByteArray();
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		
		//1.3、字节数组到字节文件的拷贝
		try {
			InputStream in = new ByteArrayInputStream(datas);
			OutputStream out = new FileOutputStream("src2/com/sxt/IO/images/p1_copy.jpg");
			copy(in,out);

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}			
	}
	public static void copy(InputStream in,OutputStream out){
		try {
			//3.1、文件的读取操作
			int tem;
			byte[] flush = new byte[1024];
			try {
				while((tem = in.read(flush))!=-1){
					//3.2、文件的写出操作
					out.write(flush,0,tem);
					out.flush();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		} finally{
			//资源的释放（close）
			close(in, out);
		}
	}
	//2、输入流和输出流资源的释放
	public static void close(InputStream in , OutputStream out){
		if(out != null){
			try {
				//4.1、关闭资源
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		if(in != null){
			try {
				//4.2、关闭资源
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	//2.2升级版：多个资源的释放（因为在输入流和输出流的实现类中都有closeable接口）
	public static void close(Closeable...clos){
		for(Closeable io : clos){
			try {
				io.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}