一，介绍IO流：
IO流：是指在计算机程序中用于处理输入和输出的数据流。
**注：**进行读写文件，读写的对象可以是文件，可以是网页内容。
I： ----input 输入：从程序外到程序里。把文档信息读到程序。
O ：---output 输出：信息从程序里输送到程序外。
流：（管道）：输送方法，信息在程序和程序外进行的交流。
二，IO流分类：
共6种：
根据流方向： 输入流 输出流。
根据流承载信息的大小： 字节流：（1个字节8位） 字符流：两个字节（16位能处理汉字）
根据流的功能：节点流：一根管处理某种数据对应的流 处理流：管套管嵌套处理。
补： 节点流和处理流区别：
1字符流和字节流都是节点流（只有输入输出功能） 处理流（有其它功能）
2节点流直接连接数据源，处理流连接节点流对象。
三，Io流使用举例：
1字节输入流读取文本文件：
public static void main(String[] args) throw IOException{
//获取信息源
File f=new File("E:\\test.txt");
//创建IO流对象
FileInputStream f2=new FileInputStream(f);
//读取信息
int i=f2.read();
while(i!=-1){
System.out.print((char)i);
i=f2.read();
}
//关闭信息源
f2.close;
}
2，字节输出输入流读取输出图片：
public static void main(String[] args) throws IOException {
//获得数据源
File Inf=new File("E:小狮子.png");
File outf=new File("E:teat\\小狮子.png");
//获得输出流
FileInputStream f1=new FileInputStream(Inf);
FileOutputStream f2=new FileOutputStream(outf);//对应想要输出的地址
//读写信息
byte[] bys=new byte[50];//设置缓冲区，弥补read()一次只读一个字节的缺点
int i=f1.read(bys);
while (i!=-1){
f2.write(bys);//输出流对应write。
i=f1.read(bys);
}
//关闭资源；后开的先关
f2.close();
f1.close();
}
3字符流输入：（读取汉字）
public static void main(String[] args) throws IOException {
//获得数据源
File Inf=new File("E:test.txt");
//获取管道对象：
//读汉字
FileReader f=new FileReader(Inf);
char[] cs=new char[50];//缓冲区
int i=f.read(cs);
while (i!=-1){//下一位无内容时，条件不满足，停止循环
System.out.println(cs);
i=f.read(cs);//判断下一位是否有内容
}
//关闭
f.close();
}
4，字符流输出：
public static void main(String[] args) throws IOException {
//获得信息源
File file=new File("E:test.txt");
//获得字符输出流对象，输出管道
FileWriter fw=new FileWriter(file,true);//没有条件会覆盖当前test内容,有ture条件会在末尾追加。默认是false会覆盖内容。
//写入
Scanner input =new Scanner(System.in);
System.out.println("输入信息，输入exit退出");
String str=input.next();
while (!"exit".equals(str)){
fw.write(str+"\n");
System.out.println("输入信息，输入exit退出");
str=input.next();
}
//关闭流对象
fw.close();
}
4，缓冲字节流（处理流）：
相较于使用缓冲区读取IO流信息，使用缓冲流更加快捷迅速。
public static void main(String[] args) throws IOException {
//1.有一个源图片
File f1 = new File("d:\\LOL.jpg");
//2.有一个目标图片：
File f2 = new File("d:\\LOL2.jpg");
//3.有一个输入的管道 接 到 源文件：
FileInputStream fis = new FileInputStream(f1);
//4.有一个输出的管道 接到 目标文件上：
FileOutputStream fos = new FileOutputStream(f2);
//5.功能加强，在FileInputStream外面套一个管：BufferedInputStream:
BufferedInputStream bis = new BufferedInputStream(fis);
//6.功能加强，在FileOutputStream外面套一个管：BufferedOutputStream:
BufferedOutputStream bos = new BufferedOutputStream(fos);
//7.开始动作 ：
byte[] b = new byte[1024*6];
int len = bis.read(b);
while(len!=-1){
bos.write(b,0,len);
/* bos.flush(); 底层已经帮我们做了刷新缓冲区的操作，不用我们手动完成：底层调用flushBuffer()*/
len = bis.read(b);
}
//8.关闭流：
//倒着关：
//如果处理流包裹着节点流的话，那么其实只要关闭高级流（处理流），那么里面的字节流也会随之被关闭。
bos.close();
bis.close();
/*fos.close();
fis.close();*/
}
5，缓冲字符流（处理流）：
public static void main(String[] args) throws IOException {
//1.有一个源文件：
File f1 = new File("d:\\Test.txt");
//2.有一个目标文件：
File f2 = new File("d:\\Demo.txt");
//3.需要一个管 接到 源文件：
FileReader fr = new FileReader(f1);
//4.需要一根管接到目标文件：
FileWriter fw = new FileWriter(f2);
//5.套一根管在输入字符流外面：
BufferedReader br = new BufferedReader(fr);
//6.套一根管在输出字符流外面：
BufferedWriter bw = new BufferedWriter(fw);
//7.开始动作：
//方式1：读取一个字符，输出一个字符：
/*int n = br.read();
while(n!=-1){
bw.write(n);
n = br.read();
}*/
//方式2:利用缓冲数组：
/*char[] ch = new char[30];
int len = br.read(ch);
while(len!=-1){
bw.write(ch,0,len);
len = br.read(ch);
}*/
//方式3：读取String：
String str = br.readLine();//每次读取文本文件中一行，返回字符串
while(str!=null){
bw.write(str);
//在文本文件中应该再写出一个换行：
bw.newLine();//新起一行
str = br.readLine();
}
//8.关闭流
bw.close();
br.close();
}
6，转换流（处理流）：
【1】转换流：作用：将字节流和字符流进行转换。
【2】转换流 属于 字节流还是字符流？属于字符流
InputStreamReader ：字节输入流 --->字符的输入流
OutputStreamWriter ： 字符输出流 -->字节的输出流
//将输入的字节流转换为字符流
public static void main(String[] args) throws IOException {
//文件---》程序：
//1.有一个源文件：
File f = new File("d:\\Test.txt");
//2.需要一个输入的字节流接触文件：
FileInputStream fis = new FileInputStream(f);
//3.加入一个转换流，将字节流转换为字符流：（转换流属于一个处理流）
//将字节转换为字符的时候，需要指定一个编码，这个编码跟文件本身的编码格式统一
//如果编码格式不统一的话，那么在控制台上展示的效果就会出现乱码
//InputStreamReader isr = new InputStreamReader(fis,"utf-8");
//获取程序本身的编码--》utf-8
InputStreamReader isr = new InputStreamReader(fis);
//4.开始动作，将文件中内容显示在控制台：
char[] ch = new char[20];
int len = isr.read(ch);
while(len!=-1){
//将缓冲数组转为字符串在控制台上打印出来
System.out.print(new String(ch,0,len));
len = isr.read(ch);
}
//5.关闭流：
isr.close();
}
public static void main(String[] args) throws IOException {
//1.有一个源文件
File f1 = new File("d:\\Test.txt");
//2.有一个目标文件：
File f2 = new File("d:\\Demo.txt");
//3.输入方向：
FileInputStream fis = new FileInputStream(f1);
InputStreamReader isr = new InputStreamReader(fis,"utf-8");
//4.输出方向：
FileOutputStream fos = new FileOutputStream(f2);
OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
//5.开始动作：
char[] ch = new char[20];
int len = isr.read(ch);
while(len!=-1){
osw.write(ch,0,len);
len = isr.read(ch);
}
//6.关闭流：
osw.close();
isr.close();
}
7，数据流（处理流）：
【1】数据流：用来操作基本数据类型和字符串的
【2】 DataInputStream:将文件中存储的基本数据类型和字符串 写入 内存的变量中
DataOutputStream: 将内存中的基本数据类型和字符串的变量 写出 文件中
//利用DataOutputStream向外写出变量：
public class Test01 {
//这是一个main方法，是程序的入口：
public static void main(String[] args) throws IOException {
//DataOutputStream: 将内存中的基本数据类型和字符串的变量 写出 文件中
/*File f = new File("d:\\Demo2.txt");
FileOutputStream fos = new FileOutputStream(f);
DataOutputStream dos = new DataOutputStream(fos);*/
DataOutputStream dos = new DataOutputStream(new FileOutputStream(new File("d:\\Demo2.txt")));
//向外将变量写到文件中去：
dos.writeUTF("你好");
dos.writeBoolean(false);
dos.writeDouble(6.9);
dos.writeInt(82);
//关闭流：
dos.close();
}
}
//读取的程序：
public class Test02 {
//这是一个main方法，是程序的入口：
public static void main(String[] args) throws IOException {
//DataInputStream:将文件中存储的基本数据类型和字符串 写入 内存的变量中
DataInputStream dis = new DataInputStream(new FileInputStream(new File("d:\\Demo2.txt")));
//将文件中内容读取到程序中来：
System.out.println(dis.readUTF());
System.out.println(dis.readBoolean());
System.out.println(dis.readDouble());
System.out.println(dis.readInt());
//关闭流：
dis.close();
}
}
8，对象流（处理流）；
【1】对象流：ObjectInputStream，ObjectOnputStream
用于存储和读取基本数据类型数据或对象的处理流。
它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
【2】序列化和反序列化：
ObjectOutputStream 类 ： 把内存中的Java对象转换成平台无关的二进制数据，从而允许把这种二进制数据持久地保存在磁盘上，或通过网络将这种二进制数据传输到另一个网络节点。---->序列化
ObjectInputStream类 ： 当其它程序获取了这种二进制数据，就可以恢复成原来的Java对象。---->反序列化
//实验类
public class Student implements Comparable<Student>, Serializable {
/**
* 属性类型以包装类型存在！
*/
private Integer stuId;
private String stuName;
private Integer age;
private String sex;
public Student() {
}
public Student(Integer stuId, String stuName, Integer age, String sex) {
this.stuId = stuId;
this.stuName = stuName;
this.age = age;
this.sex = sex;
}
public Integer getStuId() {
return stuId;
}
public void setStuId(Integer stuId) {
this.stuId = stuId;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) throws Exception {
this.age = age;
throw new Exception("提醒的内容");
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return Objects.equals(stuId, student.stuId) &&
Objects.equals(stuName, student.stuName) &&
Objects.equals(age, student.age) &&
Objects.equals(sex, student.sex);
}
@Override
public int hashCode() {
return Objects.hash(stuId, stuName, age, sex);
}
@Override
public String toString() {
return "Student{" +
"stuId=" + stuId +
", stuName='" + stuName + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
@Override
public int compareTo(Student o) {
/*if(stuId>o.stuId){
return -1;
}else if(stuId<o.stuId){
return 1;
}else{
return 0;
}*/
return stuName.compareTo(o.stuName);
}
}
//序列化
public static void main(String[] args) throws IOException {
//使用对象流"将内存对象----存储到外部文件：序列化：永久存储信息
//将外部文件里信息，读取到内存：反序列化
//获得信息源对象：
File file=new File("E:test.txt");
//获得管道对象
//序列化,要有标记接口
FileOutputStream fos=new FileOutputStream(file);//节点流
ObjectOutputStream oos=new ObjectOutputStream(fos);//处理流
//开始序列化
Student stu=new Student(1,"xiao",24,"nan");
oos.writeObject(stu);
//关闭流对象,同一个方向，当有多层流对象时，关闭最里层。
oos.close();
System.out.println("序列化成功");
}
//反序列化
public static void main(String[] args) throws IOException, ClassNotFoundException {
//获得信息源对象：
File file=new File("E:test.txt");
//获得管道对象
//序列化,要有标记接口
FileInputStream fos=new FileInputStream(file);//节点流
ObjectInputStream oos=new ObjectInputStream(fos);//处理流
Student stu=(Student)oos.readObject();
System.out.println(stu);
oos.close();
System.out.println("反序列化成功");
}
补：
serialVersionUID：
凡是实现Serializable接口（标识接口）的类都有一个表示序列化版本标识符的静态常量:
➢private static final long serialVersionUID;
➢serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序加化时是否兼容。
➢如果类没有显示定义这个静态变量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。故建议，显式声明。
➢简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)