Java基础之IO操作（一）

一、FileInputStream

1. 第一个程序，理解操作步骤

public static void main(String[] args) {
//1、创建源
File src = new File("abc.txt");
//2、选择流
try {
	InputStream  is =new FileInputStream(src);
	//3、操作 (读取)
	int data1  = is.read(); //第一个数据x
	int data2  = is.read(); //第二个数据y
	int data3  = is.read(); //第三个数据z
	int data4  = is.read(); //文件的末尾返回-1
	System.out.println((char)data1);
	System.out.println((char)data2);
	System.out.println((char)data3);
	System.out.println(data4);
	//4、释放资源
	is.close();
} catch (FileNotFoundException e) {
	e.printStackTrace();
} catch (IOException e) {
	e.printStackTrace();
	}
}

2. 标准操作步骤

//1、创建源
File src = new File("abc.txt");
//2、选择流
InputStream  is =null;
try {
	is =new FileInputStream(src);
	//3、操作 (读取)
	int temp ;
	while((temp=is.read())!=-1) {
		System.out.println((char)temp);
	}		
		
} catch (FileNotFoundException e) {
	e.printStackTrace();
} catch (IOException e) {
	e.printStackTrace();
}finally {
	//4、释放资源
	try {
		if(null!=is) {
			is.close();
		}
	} catch (IOException e) {
		e.printStackTrace();
	}
}
}

3. 分段读取

public static void main(String[] args) {
//1、创建源
File src = new File("abc.txt");
//2、选择流
InputStream  is =null;
try {
	is =new FileInputStream(src);
	//3、操作 (分段读取)
	byte[] flush = new byte[1024*10]; //缓冲容器
	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 {
	//4、释放资源
	try {
		if(null!=is) {
			is.close();
		}
	} catch (IOException e) {
		e.printStackTrace();
	}
}
}

二、FileOutputStream

1. 基础操作

public static void main(String[] args) {
//1、创建源
File dest = new File("dest.txt");
//2、选择流
OutputStream os =null;
try {
	os = new FileOutputStream(dest,true);
	//3、操作(一次写出)
	String msg ="IO is so easy\r\n";
	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 (Exception e) {
	}
}
}

三、FileReader

1. 分段读取

public static void main(String[] args) {
//1、创建源
File src = new File("abc.txt");
//2、选择流
Reader  reader =null;
	try {
		reader =new FileReader(src);
		//3、操作 (分段读取)
		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 {
		//4、释放资源
		try {
			if(null!=reader) {
				reader.close();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

四、FileWriter

1. 基础操作

public static void main(String[] args) {
//1、创建源
File dest = new File("dest.txt");
//2、选择流
Writer writer =null;
try {
	writer = new FileWriter(dest);
	//3、操作(写出)
	//写法一
//	String msg ="IO is so easy\r\n锄禾日当午";
//	char[] datas =msg.toCharArray(); // 字符串-->字符数组
//	writer.write(datas,0,datas.length);
	//写法二
	/*String msg ="IO is so easy\r\n锄禾日当午";
	writer.write(msg);	
	writer.write("add");		
	writer.flush();*/
			
	//写法三
	writer.append("IO is so easy\r\n").append("锄禾日当午");
	writer.flush();
}catch(FileNotFoundException e) {		
	e.printStackTrace();
}catch (IOException e) {
	e.printStackTrace();
}finally{
	//4、释放资源
	try {
		if (null != writer) {
			writer.close();
		} 
	} catch (Exception e) {
	}
}
}

五、ByteArrayInputStream

1. 字节数组输入流（字节数组 不要太大）

public static void main(String[] args) {
//1、创建源
byte[] src = "talk is cheap show me the code".getBytes();
//2、选择流
InputStream  is =null;
try {
	is =new ByteArrayInputStream(src);
	//3、操作 (分段读取)
	byte[] flush = new byte[5]; //缓冲容器
	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 {
	//4、释放资源
	try {
		if(null!=is) {
			is.close();
		}
	} catch (IOException e) {
		e.printStackTrace();
	}
}
}

六、ByteArrayOutputStream

1. 基本操作

public static void main(String[] args) {
//1、创建源
byte[] dest =null;
//2、选择流 （新增方法）
ByteArrayOutputStream baos =null;
try {
	baos = new ByteArrayOutputStream();
	//3、操作(写出)
	String msg ="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{
	//4、释放资源
	try {
		if (null != baos) {
			baos.close();
		} 
	} catch (Exception e) {
	}
}
}

七、字节数组应用

1. 图片读取到字节数组、字节数组写出到文件

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) {
			}
		}
	}