IO流（一）
目录
一.IO流简介
四大IO抽象类
InputSteam
OutputSteam
Reader
Writer
流的概念细分
按流的方向分类：
按处理的数据单元分类：
按处理对象不同分类：
总结：
常用流对象
文件字节流
通过缓冲区提高读写效率
通过字节缓冲流提高读写效率
一.IO流简介
对于任何程序设计语言而言，输入输出系统都是非常核心的功能。程序运行需要数据，数据的获取往往需要跟外部系统进行通信，外部系统可能是文件，数据库，其他程序，网络，IO设备等等。外部系统比较复杂多变，那么我们有必要根据莫种手段进行抽象，屏蔽外部的差异，从而实现更加便捷的编程。
输入（input）指的是：可以让程序从外部系统获取数据（核心含义是“读”，读取外部数据）。
输出（output）指的是：程序输出数据给外部系统从而可以操作外部系统（核心含义是“写”，将数据写出到外部系统）。
四大IO抽象类
InputSteam
此抽象类是表示字节输入流的所有类的父类，InputSteam是一个抽象类，它不可实例化。数据的读取需要他的子类来实现。
常用方法：
int read()：读取一个字节的数据，并将字节的值作为int类型返回（0~255之间的一个值）。如果未读出字节返回-1。
void close()：关闭输出流对象，释放相关系统资源。
OutputSteam
此抽象类表示字节输出流的所有类的父类。输出流接收输出字节并将这些字节发送到某个目的地。
常用方法：
void write(int n)：向目的地中写入一个字节。
void close()：关闭输出流对象，释放相关系统资源。
Reader
Reader用于读取字符流抽象类，数据单位为字符。
常用方法：
int read()：读取一个字符的数据，并将字符的值作为int类型返回（0~65535之间的一个值）。如果未读出字符返回-1.
void close()：关闭流对象，释放系统相关资源。
Writer
Writer用于输出的字符流抽象类，数据单位为字符。
void write(int n)：向输出流中写入一个字符。
void close()：关闭输出流对象，释放相关系统资源。
流的概念细分
按流的方向分类：
1.输入流：数据流从数据源到程序。
2.输出流：数据流从程序到目的地。
按处理的数据单元分类：
1.字节流：以字节为单位获取数据。
2.字符流：以字符为单位获取数据。
按处理对象不同分类：
1.节点流：可以直接从数据元或目的地读写数据。
2.处理流：不直接连接到数据源或目的地，是“处理流的流”。通过对其他流的处理提高程序性能。
总结：
1. InputStream/OutStream
字节流的抽象类。
2.Reader/Writer
字符流的抽象类。
3.FileInputStream/FileOutputStream
节点流：以字节为单位直接操作文件。
4.ByteArrayInputStream/ByteArrayOutputStream
节点流：以字节为单位直接操作“字节数组对象”。
5.ObjectInputStream/ObjectOutputStream
处理流：以字节为单位，直接操作“对象”。
6.DateInputStream/DateOutputStream
处理流：以字节为单位直接操作“基本数据类型与字符串类型”。
7.FileReader/FileWriter
节点流：以字符为单位直接操作文本文件。
8.BufferedReader/BufferedWriter
处理流：将Reader/Writer对象进行包装，增加缓存功能，提高读写效率。
9.BufferedInputStream/BufferedOutputStream
处理流：将InputStream/OutputStream对象进行包装，增加缓存功能，提高读写效率。
10.InputStreamReader/OutputStreamWriter
处理流：将字节流对象转化为字符流对象。
11.PrintStream
处理流：将OutputStream进行包装，可以方便的输出字符，更加灵活。
常用流对象
文件字节流
.FileInputStream/FileOutputStream
节点流：以字节为单位直接操作文件。
public class study {
public static void main(String[] args) {
FileInputStream fis=null;
try {
//创建字节输入流对象
fis=new FileInputStream("d:/dd.txt");
StringBuilder sb=new StringBuilder();
int temp=0;
while ((temp=fis.read())!=-1){
System.out.println(temp);
sb.append(temp);
}
System.out.println(sb.toString());
}catch (Exception e){
e.printStackTrace();
}finally {
try {
if (fis!=null){
fis.close();
}
}catch (Exception e){
e.printStackTrace();
}
} //文件字节输出流
FileInputStream fi1=null;
FileOutputStream fo1=null;
try {
//创建文件字节输入流对象
fi1=new FileInputStream("d:/dd.txt");
fo1=new FileOutputStream("d:/wb.txt");
int temp=0;
while ((temp= fi1.read())!=-1){
fo1.write(temp);
}
//将数据从内存写入到磁盘中
fo1.flush();
}catch (Exception e){
e.printStackTrace();
}finally {
try {
if (fi1!=null){
fi1.close();
}
if(fo1!=null){
fo1.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}通过缓冲区提高读写效率
方式一：
通过创建一个指定长度的字节数组作为缓冲区，以此来提高IO流的读写效率。
FileInputStream fi1=null;
FileOutputStream fo1=null;
try {
//创建文件字节输入流对象
fi1=new FileInputStream("d:/dd.txt");
fo1=new FileOutputStream("d:/wb.txt");
//创建一个缓冲区
byte[] buff=new byte[1024];
int temp=0;
while ((temp= fi1.read(buff))!=-1){
fo1.write(temp);
}
//将数据从内存写入到磁盘中
fo1.flush();
}catch (Exception e){
e.printStackTrace();
}finally {
try {
if (fi1!=null){
fi1.close();
}
if(fo1!=null){
fo1.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}方式二：
通过创建一个字节数组作为缓冲区，数组长度是通过流对象的availble（）返回当前文件预估长度来定义的。如果文件较大，不建议使用。
//创建一个缓冲区
byte[] buff=new byte[fi1.available()];
int temp=0;
while ((temp= fi1.read(buff))!=-1){
fo1.write(temp);
}
//将数据从内存写入到磁盘中
fo1.flush();通过字节缓冲流提高读写效率
FileInputStream fi2=null;
FileOutputStream fo2=null;
BufferedInputStream bi1=null;
BufferedOutputStream bo1=null;
try {
fi2=new FileInputStream("d:/dd.txt");
fo2=new FileOutputStream("d:/wb.txt");
bi1=new BufferedInputStream(fi2);
bo1=new BufferedOutputStream(fo2);
int t=0;
while ((t=bi1.read())!=0){
bo1.write(t);
}
}catch (Exception e){
e.printStackTrace();
}finally {
try {
//关闭的顺序：后开的先关闭
if (bi1!=null){
bi1.close();
}
if (bo1!=null){
bo1.close();
}
if(fi2!=null){
fi2.close();
}
if (fo2!=null){
fo2.close();
}
}catch (Exception e){
e.printStackTrace();
}
}