在这里插入图片描述

博主：_LJaXi
专栏： Java | 从跨平台到跨行业
开发工具：IntelliJ IDEA Community Edition 2022.3.3

Java IO流

中秋特供啦 🥮
Java Io 🍔
- 什么是流
- 流的分类
- 文件字节输入流
- - 1. 条件循环解决
  - - 1 (2) 读取特性
  - 2. 数组存储解决
- 文件字节输出流
- - - 输出流构造方法
- 字节流复制文件
- 字节缓冲流
- - BufferedInputStream
  - BufferedInputStream 自定义读取部分数据
  - BufferedOutputStream
- 对象流
- - Student 类
  - ObjectOutStream
  - ObjectInputSteam
  - 序列化和反序列化注意点

中秋特供啦 🥮

提前祝大家中秋 | 国庆快乐 🥮🥮🥮

Java Io 🍔

什么是流

I: Input | 输入

O: Output | 输出

流的分类

按照数据的流向
输入流：读数据
输出流：写数据

按照数据类型来分
字节流
字节输入流
字节输出流

字符流
字符输入流
字符输出流

输入流,输出流

字节流,字符流

文件字节输入流

FileInputStream

package FileInput;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * Author: _LJaXi
 * @author ASUS
 */
class FileInput {
    public static void main(String[] args) throws IOException {
        try {
            FileInputStream fis = new FileInputStream("d:\\aaa.txt");
            // 一次读取多个字节,存到数组中
            // 创建一个长度为3的数组 / 字节类型
            byte[] buf = new byte[3];
            int count = 0;
            // 条件判断循环
            while ((count = fis.read(buf)) != -1) {
                System.out.print(new String(buf,0,count));
            }

            // 3. 关闭
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

1. 条件循环解决

package main.java.com.mycode;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * Author: _LJaXi
 * @author ASUS
 */
class MyIo {
  public static void main(String[] args) throws IOException {
    try {
      FileInputStream fis = new FileInputStream("d:\\aaa.txt");
      // 读取
      System.out.println(fis.read());
      int data = 0;
      // 循环打印字节
      while ((data = fis.read()) != -1) {
        System.out.print((char) data);
      }
      // 3. 关闭
      fis.close();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
  }
}

1 (2) 读取特性

package main.java.com.mycode;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * Author: _LJaXi
 * @author ASUS
 */
class MyIo {
  public static void main(String[] args) throws IOException {
    try {
      FileInputStream fis = new FileInputStream("d:\\aaa.txt");
      // 一次读取多个字节,存到数组中
      // 创建一个长度为3的数组 / 字节类型
      byte[] buf = new byte[3];
      // 返回实例读取的个数
      int count = fis.read(buf);
      // 打印字符串 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));
      System.out.println(count3);

      // 若文件内字符太短，可能会出现读取数组you多余元素问题，那是你的上次buf数组没有清空导致的
      // 可以使用
      // System.out.println(new String(buf, index(索引), count3)); 来清理多余的元素

      // new String(buf)参数：
      // 1. param1 是一个字节数组，用于构建新的字符串对象
      // 2. param2 是偏移量（offset），表示从 param1 的索引为 param2 的位置开始构建字符串
      // 3. param3 是长度（length），表示构建字符串的长度

      // 3. 关闭
      fis.close();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
  }
}

2. 数组存储解决

package main.java.com.mycode;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * Author: _LJaXi
 * @author ASUS
 */
class MyIo {
  public static void main(String[] args) throws IOException {
    try {
      FileInputStream fis = new FileInputStream("d:\\aaa.txt");
      // 一次读取多个字节,存到数组中
      // 创建一个长度为3的数组 / 字节类型
      byte[] buf = new byte[3];
     int count = 0;
     // 条件判断循环
     while ((count = fis.read(buf)) != -1) {
         System.out.print(new String(buf,0,count));
     }

      // 3. 关闭
      fis.close();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
  }
}

文件字节输出流

FileOutputStream

package main.java.com.mycode;

import java.io.FileOutputStream;

/**
 * Author: _LJaXi
 * @author ASUS
 */

public class FileOutput {
  public static void main (String[] args) throws Exception {
    // 1. 创建文件字节输出流对象
    // 若不想覆盖原本内容，将构造方法append，设置为true
    FileOutputStream fos = new FileOutputStream("d://aaa.txt", true);
    // 2. 写入文件
    // fos.write(97);
    // fos.write('b');
    // fos.write('c');
    String str = "helloworld";
    // 获取字符串所对应的字节数组
    fos.write(str.getBytes());
    // 3. 关闭
    fos.close();
    System.out.println("执行完毕");
  }
}

输出流构造方法

// 某个构造方法有个形参 append，这个构造方法的 append 若为true 表明不覆盖原本内容
public FileOutputStream(String name, boolean append)
        throws FileNotFoundException
    {
        this(name != null ? new File(name) : null, append);
    }

字节流复制文件

package CopyFile;

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

/*
* 使用文件字节流实现文件的复制
* */
public class CopyFile {
    public static void main(String[] args) throws IOException {
        // 1. 先用文件字节输入流读到内存中
        FileInputStream fis = new FileInputStream("C:\\Users\\ASUS\\Desktop\\凌波.png");
        // 2. 再用一个文件字节输出流写入到硬盘
        FileOutputStream fos = new FileOutputStream("C:\\Users\\ASUS\\Desktop\\凌波丽.jpg");
        // 3. 一边读 一边写
        byte[] buf = new byte[1024];
        int count = 0;
        while((count=fis.read(buf)) != -1) {
            fos.write(buf,0,count);
        }

        // 4. 关闭流
        fis.close();
        fos.close();
        System.out.print("复制完毕");
    }
}

字节缓冲流

BufferedInputStream / Buffered0utputStream

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

BufferedInputStream

package Buffered;

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

/*
* 使用字节缓冲流读取
* BufferedInputStream
* @Tip 我想和 符韬_(pinegg) 一起玩
* */
public class BufferedStream {
    public static void main(String[] args) throws IOException {
        // 1. 创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        // 增强底层流
        BufferedInputStream bis = new BufferedInputStream(fis);
        // 2. 读取 bis 读文件会放在缓冲区，提高效率
        int count = 0;
        // bis.read() 并不是读一个字节，先把一部分数据读到bis缓冲区内，调用已经读了8k了
        // private static int DEFAULT_BUFFER_SIZE = 8192;
        while ((count=bis.read()) != -1) {
            System.out.print((char) count);
        }

        // 3. 关闭
        bis.close(); // 缓冲流close之后, 会自动帮你关闭输入流 fis.close()
    }
}

BufferedInputStream 自定义读取部分数据

package Buffered;

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

/*
* 使用字节缓冲流读取
* BufferedInputStream
* @author 符韬是谁？
* */
public class BufferedStream {
    public static void main(String[] args) throws IOException {
        // 1. 创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        // 增强底层流
        BufferedInputStream bis = new BufferedInputStream(fis);
        // 2. 读取 bis 读文件会放在缓冲区，提高效率
        int count = 0;
        // bis.read() 并不是读一个字节，先把一部分数据读到bis缓冲区内，调用已经读了8k了
        // private static int DEFAULT_BUFFER_SIZE = 8192;
        // 当然你也可以自己定义把一部分数据读取到缓冲区, 下方注释写法
        byte[] buf = new byte[6000];
        while ((count=bis.read(buf)) != -1) {
            System.out.print(new String(buf, 0, count));
        }

        // 3. 关闭
        bis.close(); // 缓冲流close之后, 会自动帮你关闭输入流 fis.close()
    }
}

BufferedOutputStream

package Buffered;
import java.io.*;

/*
 * 使用字节缓冲流写入
 * BufferedOutputStream
 * @time 2023年9月11日14:19:47
 * @author _LJaXi
 * @tip 想秀阿卡丽
 * */

public class OutputStream {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream("d:\\aaa.txt", true);
            BufferedOutputStream bos = new BufferedOutputStream(fos);

            String data = "LOL";
            bos.write(data.getBytes()); // 写入 8k 到缓冲区
            fos.flush(); // 刷新到硬盘

            /*---------------------------------------------------------------
            * bos.flush()的作用是将缓冲区中的数据立即刷新（写入）到硬盘中
            * 当使用BufferedOutputStream写入数据时，数据通常会先被存储在内部的缓冲区中，直到缓冲区达到一定的容量或者手动调用flush()方法
            * ---------------------------------------------------------------
            * flush()方法的使用是为了确保数据被及时写入硬盘，而不是一直停留在缓冲区
            * 在调用flush()方法后，任何未写入的数据将被立即写入到硬盘中，这样可以避免数据丢失的风险
            * ---------------------------------------------------------------
            * 在流关闭之前或发生异常时，也会自动调用flush()方法，确保所有数据都被写入硬盘
            * ---------------------------------------------------------------*/

            bos.close(); // 内部也会调用 flush() 方法
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对象流

增强了缓冲区功能
增强了读写8种基本数据类型和字符串功能
增强了读写对象的功能 {

readObject() 从流中读取一个对象

writeObject(Object obj) 向流中写入一个对象

}

使用流传输对象的过程称为序列化(写入)、反序列化(读取)

Student 类

package ObjectStream;

import java.io.Serializable;

// 要想序列化，类必须实现一个接口，为标记接口
public class Student implements Serializable {
    private String name;
    private int age;
    public Student() {

    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    // this is 重写 toString 方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

ObjectOutStream

package ObjectStream;

import java.io.*;
/*
* 序列化类必须要实现 Serializable 接口(标记接口)
* ObjectOutputStream
* @time 2023年9月14日13:49:52
* @author _LJaXi
* @tip 阿卡丽5连败
* */
public class OutStream {
    public static void main(String[] args)throws IOException {
        // 1. 创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\aaa.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        // 2. 序列化（写入操作）
        Student zs = new Student("张三", 20);
        oos.writeObject(zs);
        // 3. 关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}

ObjectInputSteam

package ObjectStream;

import java.io.*;

/*
* ObjectInputStream 反序列化(读取重构成对象)
* @time 2023年9月14日23:31:23
* @author _LJaXi
* @tip 阿卡丽排位3连胜
* */
public class InputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1. 创建对象流
        FileInputStream fis = new FileInputStream("d:\\aaa.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        // 2. 读取文件(反序列化)
        Student s = (Student)ois.readObject();
        // Student s2 = (Student)ois.readObject(); // 不能读取多次
        // 3. 关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(s.toString());
    }
}

序列化和反序列化注意点

序列化类必须实现 Serializable 接口

序列化类中对象属性要求实现 Serializable 接口

序列化类中对象属性要求实现 Serializable 接口意思为：

public class Student implements Serializable {
    private String name;
    private int age;
    private Class class; // Class类要实现 Serializable 接口
    // ... 其他内容
}