IO学习二（四个抽象类）

一、总览

四个抽象类：

抽象类	说明	常用方法
InputStream	字节输入流的父类，数据单位为字节	int read(), void close()
OutputStream	字节输出流的父类，数据单位为字节	void write(int), void flush(), void close()
Reader	字符输入流的父类，数据单位为字符	int read(), void close()
Writer	字符输出流的父类，数据单位为字符	void write(String), void flush(), void close()

二、FileInputStream&FileOutputStream

• FileInputStream:通过字节的方式读取文件，适合读取所有类型的文件（图像，视屏等），全字符请考虑FileReader
• FileOutputStream:通过字节的方式写出或追加数据到文件，适合所有类型的文件（图像、视屏等），全字符请考虑FileWriter
  例题1：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

/*
 * 四个步骤：分段读取
 * 1、创建源
 * 2、选择流
 * 3、操作
 * 4、释放资源
 */
public class IOtest03 {
	public static void main(String[] args){
		//创建源
		File src=new File("abc.txt");
		//选择流
		InputStream is=null;
		try {
			is=new FileInputStream(src);
			//操作（读取一个字节）
			//int data1=is.read();//第一个数据h
			//System.out.println((char)data1);
			//操作(分段读取）
			byte[] flush=new byte[3];//缓存容器
			int len=-1;//接收长度
			while((len=is.read(flush))!=-1){
				//字节数组——>到字符串
				String str=new String(flush,0,len);
				System.out.println(str);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			//释放资源
			try {
				if(null!=is){
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

例题2：

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/*
 *文件字节输出流
 *1、创建源
 *2、选择流
 *3、操作
 *4、释放资源 
 */
public class IOtest04 {
	public static void main(String[] args) {
		// 1、创建源
		File arc = new File("test.txt");//文件可以不存在，会帮你创建
		// 2、选择流
		OutputStream os = null;
		//
		try {
			os = new FileOutputStream(arc,true);//true追加
			// 3、操作
			String msg = "i am so happy";
			byte[] datas = msg.getBytes();// 字符串——>到字符数组(编码）
			os.write(datas, 0, datas.length);
			os.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			// 4、释放资源
			try {
				if (null != os) {
					os.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

例题3：

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;
/*
 * 文件拷贝
 */
public class Copy {
	public static void main(String[] args){
		//1、创建源
		File src=new File("9.jpg");//源头
		File dest=new File("copy9.jpg");//目的地
		//2、选择流
		InputStream is=null;
		OutputStream os=null;
		try{
			is=new FileInputStream(src);
			os=new FileOutputStream(dest);
			//3、操作
			byte[] flush=new byte[1024];//缓存容器
			int len=-1;//长度
			while((len=is.read(flush))!=-1){
				os.write(flush,0,len);
			}
			os.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			//4、释放资源,分别关闭，先打开的后关闭
			try{
				if(null!=os){
					os.close();
				}
			}catch(IOException e){
				e.getStackTrace();
			}
			try{
				if(null!=is){
					os.close();
				}
			}catch(IOException e){
				e.getStackTrace();
			}	
		}
	}
}

三、FileReader&FileWriter

• FileReader:通过字符的方式读取文件，仅适合字符文件
• FileWriter:通过字符的方式写出或追加数据到文件中，仅适合字符文件
  例题1：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
/*
 * 四个步骤：文件字符流
 * 1、创建源
 * 2、选择流
 * 3、操作
 * 4、释放资源
 */
public class IOtest05 {
	public static void main(String[] args){
		//创建源
		File src=new File("abc.txt");
		//选择流
		Reader reader=null;
		try {
			reader=new FileReader(src);
			//操作(分段读取）
			char[] flush=new char[1024];//缓存容器
			int len=-1;//接收长度
			while((len=reader.read(flush))!=-1){
				//字符数组——>到字符串
				String str=new String(flush,0,len);
				System.out.println(str);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			//释放资源
			try {
				if(null!=reader){
					reader.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

例题2：

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;
/*
 *文件字符输出流，只能处理文件
 *1、创建源
 *2、选择流
 *3、操作
 *4、释放资源 
 */
public class IOtest06 {
	public static void main(String[] args) {
		// 1、创建源
		File arc = new File("test.txt");//文件可以不存在，会帮你创建
		// 2、选择流
		Writer writer = null;
		//
		try {
			writer = new FileWriter(arc);//true追加
			// 3、操作
			//写法一
			/*String msg = "\ni am so happy,所以我决定今晚吃多点";
			char[] datas = msg.toCharArray();// 字符串——>到字符数组
			writer.write(datas, 0, datas.length);
			writer.flush();*/
			//写法二
			/*String msg = "\ni am so happy,所以我决定今晚吃多点";
			writer.write(msg);
			writer.flush();*/
			//写法三
			writer.append("i am so happy").append("\nso今晚要吃多点");
			writer.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			// 4、释放资源
			try {
				if (null != writer) {
					writer.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

四、ByteArrayInputStream&ByteArrayOutputStream

两个是字节数组流，源头是内存，需要数据量比较小，不需要自己释放资源，gc会回收。
例题1：

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

/*
 * 四个步骤：字节数组输入流
 * 1、创建源:字节数组不要太大
 * 2、选择流
 * 3、操作
 * 4、释放资源：可以不用处理
 */
public class IOtest07 {
	public static void main(String[] args){
		//创建源
		byte[] src="talk is cheap show me the code".getBytes();
		//选择流
		InputStream is=null;
		try {
			is=new ByteArrayInputStream(src);
			//操作(分段读取）
			byte[] flush=new byte[3];//缓存容器
			int len=-1;//接收长度
			while((len=is.read(flush))!=-1){
				//字节数组——>到字符串
				String str=new String(flush,0,len);
				System.out.println(str);
			}
		
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			//释放资源
			try {
				if(null!=is){
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

例题2：

import java.io.ByteArrayOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
 * 四个步骤：文件字符流
 * 1、创建源：内部维护
 * 2、选择流：不关联源
 * 3、操作
 * 4、释放资源：可以不用
 * 获取数据：
 * toByteArray()
 * 
 */
public class IOtest08 {
	public static void main(String[] args){
		//创建源
		byte[] dest=null;
		//选择流
		ByteArrayOutputStream baos=null;
		try {
			baos=new ByteArrayOutputStream();
			//操作(写出）
			String msg="talk is cheap show me the code";
			byte[] datas=msg.getBytes();//字符串--》字节数组
			baos.write(datas,0,datas.length);
			baos.flush();
			//获取数据
			dest=baos.toByteArray();//从内存中获取数据
			System.out.println(dest.length+"--->"+new String(dest,0,baos.size()));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			//释放资源
			try {
				if(null!=baos){
					baos.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

例题3：

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、 图片读取到字节数组
 *2、 字节数组写出到文件
 */
public class IOTest09 {
	public static void main(String[] args) {
		//图片转成字节数组
		byte[] datas = fileToByteArray("p.png");
		System.out.println(datas.length);
		byteArrayToFile(datas,"p-byte.png");		
	}
	/**
	 * 1、图片读取到字节数组
	 * 1)、图片到程序  FileInputStream
	 * 2)、程序到字节数组	ByteArrayOutputStream
	 */
	public static byte[] fileToByteArray(String filePath) {
		//1、创建源与目的地
		File src = new File(filePath);
		byte[] dest =null;
		//2、选择流
		InputStream  is =null;
		ByteArrayOutputStream baos =null;
		try {
			is =new FileInputStream(src);
			baos = new ByteArrayOutputStream();
			//3、操作 (分段读取)
			byte[] flush = new byte[1024*10]; //缓冲容器
			int len = -1; //接收长度
			while((len=is.read(flush))!=-1) {
				baos.write(flush,0,len);		 //写出到字节数组中			
			}		
			baos.flush();
			return baos.toByteArray();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			//4、释放资源
			try {
				if(null!=is) {
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;		
	}
	/**
	 * 2、字节数组写出到图片
	 * 1)、字节数组到程序 ByteArrayInputStream
	 * 2)、程序到文件 FileOutputStream
	 */
	public static void byteArrayToFile(byte[] src,String filePath) {
		//1、创建源
		File dest = new File(filePath);
		//2、选择流
		InputStream  is =null;
		OutputStream os =null;
		try {
			is =new ByteArrayInputStream(src);
			os = new FileOutputStream(dest);
			//3、操作 (分段读取)
			byte[] flush = new byte[5]; //缓冲容器
			int len = -1; //接收长度
			while((len=is.read(flush))!=-1) {
				os.write(flush,0,len);			//写出到文件	
			}		
			os.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			//4、释放资源
			try {
				if (null != os) {
					os.close();
				} 
			} catch (Exception e) {
			}
		}
	}
}