一.IO流概述
1.定义：Java的IO流是实现输入输出的基础，它可以方便地实现数据的输入/输出操作。
2.流的分类:
(1)按流向来分：输入流和输出流
(2)按操作的数据来分：字节流和字符流
(3)按流的角色来分:节点流和处理流
二.IO流类图
常用流分类：
通常来说，字节流的功能比字符流强大，因为计算机里所有的数据都是二进制的，而字节流可以处理所有的二进制文件，但如果使用字节流来处理文本文件，则需要将字节转换为字符，这增加了编程复杂度。所以有这样一个规则：如果操作的内容是文本，则考虑使用字符流，如果操作的内容是二进制内容，则应考虑使用字节流。
三.常用流介绍
1.转换流：输入/输出流体系中还提供了两个转换流，这两个转换流用于实现将字节流转换成字符流。
InputStreamReader将字节输入流转换成字符输入流，OutputStreamWriter将字节输出流转换成字符输出流。
public class InputStreamReaderDemo {
public static void main(String[] args) {
// 将标准字节输入流转换为字符流
InputStreamReader reader = new InputStreamReader(System.in);
// 将字符流进一步包装成缓冲流
BufferedReader buffer = new BufferedReader(reader);
String line = null;
try {
// System.out.println("请输入:");
while ((line = buffer.readLine()) != null) {
if ("exit".equals(line)) {
System.exit(1);// 读取到exit，程序退出
}
System.out.println("输出内容:" + line);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}2.缓冲流
BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedeWriter
使用缓冲流的好处:能够高效的读写信息，原理是先将数据缓存起来，然后再一起写入或者读取出来。
3.打印流
PrintStream,PrintWriter
使用打印流的好处：可以很方便的进行输出
public class PrintDemo {
public static void main(String[] args) {
printToFile();
System.out.println("success");
}
public static void printToFile(){
try {
OutputStream output = new FileOutputStream("D:\\code\\999.txt");
PrintWriter pw = new PrintWriter(new BufferedOutputStream(output));
pw.println("我是一只小小小鸟");
pw.println(true);
pw.println(999);
pw.println(1.114);
pw.flush();
pw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}4.对象流：序列化和反序列化对象
（1）什么是对象序列化
对象序列化的目标是将对象保存到磁盘中，或在网络中传输对象。
对象序列化机制允许把内存中的对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点，其他程序一旦获得这个二进制流，就可以将这种二进制流恢复成原来的java对象。
（2）如何让类是可序列化的
实现Serializable接口，该接口是一个标记接口，接口内无任何需要实现的方法。
（3）对象的序列化和反序列化
对象序列化(Serialize)是指将一个java对象写入IO流中，对象的反序列化(Deserialize)是指从IO流中恢复该java对象
（4）怎么使用对象流实现序列化
两个类:ObjectOutputStream,ObjectInputStream 对象流是处理流，需要建立在节点流的基础之上。
两个方法:writeObject(), readObject()
如果不想序列化某个成员变量，可以在声明中加入关键字 transient, 例如private transient int age;
使用方法见下面代码：（Dog类省略）
package com.gdp.xuliehua; import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream; public class TestDog {
public static void main(String[] args) {
//writeObject();
//readObject();
//writeObject2();
readObject2();
}
/**
* 将对象写入到文件中
*/
public static void writeObject(){
try {
OutputStream out = new FileOutputStream("D:\\dog.txt");
ObjectOutputStream oos = new ObjectOutputStream(out);
oos.writeInt(130);
Dog dog = new Dog("小黑",3);
oos.writeObject(dog);
oos.flush();
oos.close();
out.close();
System.out.println("OK");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} }
/**
* 从文件中读取对象
*/
public static void readObject(){
try {
InputStream in = new FileInputStream("D:\\dog.txt");
ObjectInputStream ois = new ObjectInputStream(in);
int i = ois.readInt();
Dog dog = (Dog)ois.readObject();
ois.close();
in.close();
System.out.println(i);
System.out.println(dog);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} }
/**
* 序列化多个对象，采用对象数组来实现将对象写入文件中
*/
public static void writeObject2(){
Dog dog1 = new Dog("小黑",5);
Dog dog2 = new Dog("小白",3);
Dog dog3 = new Dog("小红",6);
try {
OutputStream out = new FileOutputStream("D:\\obj.tmp");
ObjectOutputStream oos = new ObjectOutputStream(out);
Dog[] dogs = new Dog[]{dog1,dog2,dog3};
oos.writeObject(dogs);
oos.flush();oos.close();out.close();
System.out.println("ok");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} }
/**
* 将多个对象从文件中读取出来
* 1.读取出来的对象是对象数组
* 2.遍历数组，取出对象
*/
public static void readObject2(){
try {
InputStream in= new FileInputStream("D:\\obj.tmp");
ObjectInputStream ois = new ObjectInputStream(in);
Dog[] dogs = (Dog[])ois.readObject();
ois.close();in.close();
for (Dog dog : dogs) {
System.out.println(dog);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} }
}
5.ByteArrayInputStream和ByteArrayOutputStream
（1）ByteArrayInputStream包含一个内部缓冲区，该缓冲区包含从流中读取的字节。
关闭ByteArrayInputStream无效，此类的方法在关闭流后仍可被调用，而不会产生任何IOException。
（2）ByteArrayOutputStream,此类实现一个输出流，其中的数据被写入一个byte数组，缓冲区会随着数据的不断写入而自动增长，可以使用toByteArray()和toString()获取数据.
关闭ByteArrayOutputStream无效，此类的方法在关闭流后仍可被调用，而不会产生任何IOException。
(3)使用方法如下列代码:
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException; public class ByteArrayDemo {
public static void main(String[] args) {
write();
}
/**
* 写入数据，不与文件关联，写入内存
* 读取数据并显示
*/
public static void write(){
ByteArrayOutputStream bos = new ByteArrayOutputStream();
String info = "我是一只小小小小鸟!";
try {
bos.write(info.getBytes());
} catch (IOException e) {
e.printStackTrace();
}
//读取数据
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
StringBuffer buf = new StringBuffer();
byte[] bytes = new byte[1024];
int temp ;
try {
while((temp=bis.read(bytes))!=-1){
buf.append(new String(bytes, 0, temp));
}
System.out.println(buf.toString());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} }
}
6.过滤器数据流:DataInputStream和DataOutputStream
(1)DataInputStream和DataOutputStream专门用于读写基本数据类型数据，而对象流既可以读写基本数据类型的数据也可以读写对象。
(2)它是一个处理流，需要建立在节点流的基础之上,如new DataInputStream(new FileInputStream("text.txt"))
(3)DataInputStream和DataOutputStream有读写的相关方法一一对应，基本使用方法见下面代码：
import java.io.DataInputStream;
import java.io.DataOutputStream;
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 DataStreamDemo {
public static void main(String[] args) {
// write();
read();
} /**
* 向文件写入数据
*/
public static void write() {
try {
OutputStream out = new FileOutputStream("D:\\test.txt");
DataOutputStream dos = new DataOutputStream(out);
dos.writeInt(100);// 写入int数值
dos.writeDouble(99.99);// 写入double数值
dos.writeBoolean(true);// 写入boolean值
dos.writeUTF("我是一只小小小小鸟");
dos.flush();
dos.close();
out.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} } /**
* 从文件读取数据
*/
public static void read() {
try {
InputStream in = new FileInputStream("D:\\test.txt");
DataInputStream dis = new DataInputStream(in);
System.out.println(dis.readInt());
System.out.println(dis.readDouble());
System.out.println(dis.readBoolean());
System.out.println(dis.readUTF());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} }
}