I\O流

什么是流

• 概念：内存与存储设备之间传输数据的通道

流的分类

• 按方向【重点】：

  • 输入流：将<存储设备>中的内容读入到<内存>中。
  • 输出流：将<内存>中的内容写入到<存储设备>中。

• 按单位：
  • 字节流：以字节为单位，可以读写所有数据。
  • 字符流：以字符为单位，只能读写文本数据。
• 按功能：
  • 节点流：具有实际传输数据的读写功能。
  • 过滤流：在节点流的基础上增强的功能。

字节流

文件字节流

文件字节输入流

import java.io.FileInputStream;

/**
 * 演示FileInputStream的使用
 * 文件字节输入流
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1.创建文件FileInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //2.读取文件
        //fis.read()；
        //2.1单个字节读取

/*        int data = 0;
        while((data=fis.read())!=-1){
            System.out.print((char)data);
        }*/
        //2.2一次读取多个字节
/*
        byte[] buf = new byte[3];
        int count = fis.read(buf);
        System.out.println(new String(buf));
        System.out.println(count);
        int count2 = fis.read(buf);
        System.out.println(new String(buf));
        System.out.println(count2);
        int count3 = fis.read(buf);
        System.out.println(new String(buf,0,count3));//offset - 要解码的首字节的索引 length - 要解码的字节数
        System.out.println(count3);
*/
        byte[] buf = new byte[3];
        int count = 0;
        while((count=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3.关闭
        fis.close();
        System.out.println();
        System.out.println("执行完毕");
    }
}

文件字节输出流

import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * 使用文件字节流实现文件的复制
 */
public class Demo03 {
    public static void main(String[] args) throws Exception{
      //1.创建流
        //1.1文件字节流输入
        FileInputStream fis = new FileInputStream("d:\\001.jpg");
        //1.2文件字节流输出
        FileOutputStream fos = new FileOutputStream("d:\\002.jpg");
        //2.一边读，一边写
        byte[] buf = new byte[1024];
        int count = 0;
        while((count = fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        //3.关闭
        fis.close();
        fos.close();
        System.out.println("复制完毕");
    }
}

字节缓冲流

• 缓冲流：BufferedInputStream/BufferedOutputStream
  • 提高IO效率，减少访问磁盘的次数；
  • 数据存储在缓冲区，flush是将缓冲区的内容写入文件中，也可以直接close。

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * 使用字节流缓冲流读取
 * BufferedInputStream
 */

public class Demo04 {
    public static void main(String[] args)throws Exception {
        //1.创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //2.读取
/*        int data =0;
        while((data=bis.read())!=-1){
            System.out.print((char) data);
        }*/
        byte[] buf = new byte[1024];
        int count=0;
        while((count=bis.read(buf))!=-1){
            System.out.print(new String(buf,0,count));
        }
        //3.关闭
        bis.close();
    }
}

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
/**
 * 使用字节缓冲流写入文件
 * BufferedOutputStream
 */
public class Demo05 {
    public static void main(String[] args) throws Exception{
        //1.创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //2.写入文件
        for (int i = 0; i <10 ; i++) {
            bos.write("helloworld\n".getBytes());//写入8k缓冲区
            bos.flush();
        }
        //3.关闭（内部调用flush）
        bos.close();
    }
}

对象流

• 对象流：ObjectOutputStream/ObjectInputStream

  • 增强了缓冲区功能
  • 增强了读写8种基本数据类型和字符串功能
  • 增强了读写对象的功能：
    1. readObject（）从流中读取一个对象
    2. writeObject（Object obj）向流中写入一个数据

• 使用流传输对象的过程称为序列化和反序列化

1、什么是序列化与反序列化？

序列化：指把堆内存中的 Java 对象数据，通过某种方式把对象存储到磁盘文件中或者传递给其他网络节点（在网络上传输）。这个过程称为序列化。通俗来说就是将数据结构或对象转换成二进制串的过程

反序列化：把磁盘文件中的对象数据或者把网络节点上的对象数据，恢复成Java对象模型的过程。也就是将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程

2、为什么要做序列化？

①、在分布式系统中，此时需要把对象在网络上传输，就得把对象数据转换为二进制形式，需要共享的数据的 JavaBean 对象，都得做序列化。

②、服务器钝化：如果服务器发现某些对象好久没活动了，那么服务器就会把这些内存中的对象持久化在本地磁盘文件中（Java对象转换为二进制文件）；如果服务器发现某些对象需要活动时，先去内存中寻找，找不到再去磁盘文件中反序列化我们的对象数据，恢复成 Java 对象。这样能节省服务器内存。

3、Java 怎么进行序列化？

①、需要做序列化的对象的类，必须实现序列化接口：Java.lang.Serializable 接口（这是一个标志接口，没有任何抽象方法），Java 中大多数类都实现了该接口，比如：String，Integer

②、底层会判断，如果当前对象是 Serializable 的实例，才允许做序列化，Java对象 instanceof Serializable 来判断。

③、在 Java 中使用对象流来完成序列化和反序列化

ObjectOutputStream:通过 writeObject()方法做序列化操作

ObjectInputStream:通过 readObject() 方法做反序列化操作

序列化

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
 * 使用ObjectOutputStream实现对象的序列化
 *要求：
 * (1)序列化的类必须要实现serializable接口
 * (2)序列化类中的对象属性要求实现Serializable接口
 * (3)序列化版本号ID，保证序列化的类和反序列化的类是同一个类
 * (4)使用transient（瞬间的）修饰属性，这个属性不能序列化
 * (5)静态属性不能被序列化
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2.序列化（写入操作）
        Student zhangsan = new Student("张三",20);
        oos.writeObject(zhangsan);
        //3.关闭
        oos.close();
        System.out.println("执行完毕");
    }
}

反序列化

import java.io.FileInputStream;
import java.io.ObjectInputStream;

/**
 * 使用ObjectInputStream实现反序列化（读取重构对象）
 */
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileInputStream fis = new FileInputStream("d:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2.读取文件（反序列化）
        Student s = (Student) ois.readObject();
        //3.关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(s);
    }
}