一、初始Java IO

1. 什么是IO流

IO： ：即in和out，也就是输入输出，指应用程序和外部设备之间的数据传递。

流（Stream）：是一个抽象概念，是指一连串的数据（字符或字节），是以先进先出的方式发送信息的通道。

当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。

流的特点：

先进先出：最先写入输出流的数据最先被输入流读取。
顺序存取：可以一个接一个往流中写入一串字节，读出时也将按写入顺序读取一串字节，不能随机访问中间的数据。
只读或只写: 每个流只能是输入流或输出流的一种，不能同时具备两个功能，输入流只能进行读操作，对输出流只能进行写操作。在一个数据传输通道中，如果既要写入数据，又要读取数据，则要分别提供两个流。

2. IO流分类

io流主要的分类方式有一下三种：

按数据流的方向：输入流，输出流
按处理数据单位：字节流，字符流
按功能：节点流，处理流

1.输入流与输出流

输入于输出是相对于应用程序而言，比如读取文件是输入流，写文件是输出流，这点很容易搞反。

2.字节流与字符流

字节流和字符流的用法几乎完成全一样，区别在于字节流和字符流所操作的数据单元不同，字节流操作的单元是数据单元是8位的字节，字符流操作的是数据单元为16位的字符。

3. 字节流与字符流的区别：

字节流一般用来处理图像、视频、音频、PPT、Word等类型的文件。字符流一般用于处理纯文本类型的文件，如TXT文件等，但不能处理图像视频等非文本文件。用一句话说就是：字节流可以处理一切文件，而字符流只能处理纯文本文件。
字节流本身没有缓冲区，缓冲字节流相对于字节流，效率提升非常高。而字符流本身就带有缓冲区，缓冲字符流相对于字符流效率提升就不是那么大了。

二、IO流对象

1. File类

2. 字节流

输入流	InputStream
输出流	OutputStream

这两个是抽象类，是字节流的基类，所有具体的字节流实现类都是继承了这两个类。

常用的一些子类

FileInputStream : 文件输入流，非常重要的字节输入流，用于对文件进行读取操作。
BufferedInputStream : 字节输入缓冲流，内部会有一个缓冲区用来存放字节，每次都是将缓冲区存满然后发送，而不是一个字节或两个字节这样发送，效率更高。
FileOutputStream : 文件输出流，用于写入文件。
BufferedOutputStream : 起到一个缓冲的作用，效率更高。

字节输入流（ InputStream）的主要方法 :

read () : 从此输入流读取一个数据字节
read（byte[] b ）：从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中
read（byte[] b , int off , int len）: 从此输入流中将最多len个字节的数据读入一个byte数组中
close（）：关闭此输入流释放与该流关联的所有系统资源

操作演示（1）：

package com.ycxw;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
/**
 * 
 * @author 云村小威
 *
 */
public class Demo {
  public static void main(String[] args) {
    /** 读取文件内容操作 */
    // 创建File文件对象，指定文件路径
    File file = new File("E:\\Test.txt");
    try {
      // 创建文件字节输入流，读取操作（有异常）
      FileInputStream fis = new FileInputStream(file);
      BufferedInputStream bis = new BufferedInputStream(fis);
      // 定义一次性取多少个字节数组
      byte[] bytes = new byte[1024];
      // 将读取到的字节数组长度储存到变量中，为-1时表示没有数据
      int length = 0;
      // 循环数据，读取到所有数据
      while ((length = bis.read(bytes)) != -1) {
        // 将读取到的内容转换成字符串进行打印输出
        System.out.println(new String(bytes, 0, length));
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

文件内容：

操作演示（2）：

package com.ycxw;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
/**
 * 
 * @author 云村小威
 *
 */
public class Demo {
  public static void main(String[] args) {
    /** 写入内容到文件操作 */
    // 创建File文件对象，指定文件路径
    File file = new File("E:\\Test.txt");
    // 创建文件字节输出流，写入操作（有异常）
    try {
      FileOutputStream fos = new FileOutputStream(file);
      // 创建字节输出缓冲流，提高传输效率
      BufferedOutputStream bos = new BufferedOutputStream(fos);
      // 定义要输入的内容
      String text = "我是真爱粉";
      // 调用写入的方法，将字符串转换成字节数组
      bos.write(text.getBytes());
      // 关闭流
      bos.close();
      fos.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

注意：我写入的是文件之前是有内容 “哈哈哈” 的，这里写入内容到该文件中会覆盖，解决方法是通过原文件内容进行拼接

3. 字符流

与字节流类似，字符流也有两个抽象基类，分别是Reader和Writer，其他的字符流实现类都是继承这两个类。

常用的一些子类：

InputStreamReader : 从字节流到字符流的桥梁，它读取字节可以使用指定的字符集将其解码为字符。
BufferedReader : 从字符输入流中读取的文本设置一个缓冲区来提高效率，BuufferedRead是对InutSreamReader的封装。
FileReader : 用于读取字符文件的便利类，new FileReader(File file)等同于new InutSreamReader(new FileInputStream(File),"UTF-8"), 但FileReader不能指定字符编码和默认字节缓冲区大小。
OutputStreamWriter
BufferedWriter
FileWriter

字符输入流（Reader）主要方法：

read（）：读取当个字符
read（char[] c）: 将字符读入数组
read（char[] c , int off , int len）：将字符读入数组的某一部分
Flush () : 刷新该流的缓冲
close（）：关闭此流，但要先刷新它

字符缓冲流独特的方法 :

1.BufferedWriter类newLine（）：写入一个行分隔符。这个方法会自动适配所在系统的行分隔符 2.BufferedReader类readLine（）：读取一个文本的行，一次读一行。

操作演示（1）：

package com.ycxw;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
/**
 * 
 * @author 云村小威
 *
 */
public class Demo2 {
  public static void main(String[] args) {
    /** 读取文件内容操作，字符流跟字节流使用方法差不多*/
    try {
      //定定字符输入流，读取文件指定路径，高效率（便捷）
      /** FileReader 等效于 new InputStreamReader(new FileInputStream(new File),"UTF-8") */
      BufferedReader br = new BufferedReader(new FileReader(new File("E:\\Test.txt")));
      //将读取到的内容保存到变量中
      String line ;
      //循环读取，每次读取一行
      while((line = br.readLine())!=null) {
        System.out.println(line);
      }
      //关闭此流并释放与该流关联的所有系统资源
      br.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

操作演示（2）：

package com.ycxw;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
/**
 * 
 * @author 云村小威
 *
 */
public class Demo2 {
  public static void main(String[] args) {
    /** 写入内容到文件操作，字符流跟字节流使用方法差不多 */
    try {
      // 定定字符输出流，读取文件指定路径，高效率（便捷）
      /**
       * FileReader 等效于 new InputStreamReader(new FileInputStream(new File),"UTF-8")
       */
      BufferedWriter bw = new BufferedWriter(new FileWriter(new File("E:\\Test.txt")));
      // 定义要写入的内容
      String test = "你好，靓仔";
      // 调用写入方法，将字符串直接传到方法里
      bw.write(test);
      // 关闭此流并释放与该流关联的所有系统资源
      bw.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

注意：这里写入内容到该文件中也会覆盖，解决方法是通过原文件内容进行拼接

三、序列化与反序列化

1. 概念

Serialization （序列化）是一种将对象以一连串的字节描述的过程；

反序列化 deserialization 是一种将这些字节重建成一个对象的过程。将程序中的对象，放入文件中保存就是序列化，将文件中的字节码重新转成对象就是反序列化。

2. 序列化必要性

实现了数据的持久化，通过序列化可以把数据永久地保存到硬盘上
利用序列化实现远程通信，即在网络上传送对象的字节序列
在网络中数据的传输必须是序列化形式进行的

3. 实现序列化的要求

1. 只有实现 S erializable 或 Externalizable 接口的类对象才能别序列化，否则抛出异常。

2. 必须是同包，同名。

4. 序列化使用步骤演示

1. 先创建一个继承了serializable类的t类

package com.test;
import java.io.Serializable; //导入io包下的序列化类
/**
 * 1.先创建一个继承了serializable类的t类
 * @author 云村小威
 *
 */
public class Cat implements Serializable {
  private static final long serialVersionUID = 1L;
  private int id;
  private String name;
  private String sex;
  private int age;
  public Cat() {
    // TODO Auto-generated constructor stub
  }
  public Cat(int id, String name, String sex, int age) {
    super();
    this.id = id;
    this.name = name;
    this.sex = sex;
    this.age = age;
  }
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public String getSex() {
    return sex;
  }
  public void setSex(String sex) {
    this.sex = sex;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  @Override
  public String toString() {
    return id + name + sex + age;
  }
}

package com.ycxw;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import com.test.Cat;
/**
 * 
 * @author 云村小威
 *
 */
public class Demo3 {
  public static void main(String[] args) throws IOException, Exception {
    // 2.将一个猫对象序列化以及反序列化
    /**
     * 序列化 将程序中生成的对象通过流的方式保存到文本文件中
     */
    File file = new File("E:\\work.bak");
    // 通过文件流构建
    FileOutputStream fos = new FileOutputStream(file);
    // 创建序列化流
    ObjectOutputStream oos = new ObjectOutputStream(fos);
    // 实例化实体
    Cat cat = new Cat(1, "喵喵", "母", 12);
    // 通过序列化流
    oos.writeObject(cat);
    // 关闭流
    oos.close();
    fos.close();
    /**
     * 反序列化流 通过程序生成的对象借用流的方法读取文本的信息
     */
    File file2 = new File("E:\\work.bak");
    // 通过字节输入流
    FileInputStream fis = new FileInputStream(file2);
    // 创建输入流缓冲流
    BufferedInputStream bis = new BufferedInputStream(fis);
    // 创建反序列化流
    ObjectInputStream ois = new ObjectInputStream(bis);
    // 调用读取方法
    Object readObject = ois.readObject();
    // 通过对象显示内容（需要强转）
    Cat c = (Cat) readObject;
    /**
     * 打印读取的对象
     */
    System.out.println(c.toString());
    // 关闭流
    ois.close();
    bis.close();
    fos.close();
  }
}

5. FX窗口案例

1. 首先利用集合进行序列化保存多个对象进行测试

        /**
     * 通过集合保存多个对象 进行序列化 
     */
    List<Cat> list = new ArrayList<>();
    for (int i = 1; i < 2000; i++) {
      Cat miao = new Cat(0 + i, "喵喵" + i + "号", "母", 11);
      list.add(miao);
    }
    // 将猫保存到文件中（序列化操作）
    ObjectOutputStream oos2 = new ObjectOutputStream(
        new BufferedOutputStream(new FileOutputStream(new File("E:\\work.bak"))));
    // 将集合写入到序列化流
    oos2.writeObject(list);
    oos2.close();