字节流：

InputStream是字节输入流，同时也是抽象类
FileInputStream 是InputStream子类，以FileInputStream 为例进行文件读取

package test.stream;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class StreamTest {
    public static void main(String[] args) {
        File f = new File("d:/a.txt");
        try {
            FileInputStream fis = new FileInputStream(f);
            byte[] buf = new byte[1024];
            fis.read(buf);
            for (byte b : buf) {
                System.out.println(b);
            }
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

OutputStream是字节输出流，也是抽象类
FileOutputStream 是OutputStream子类，以FileOutputStream 为例向文件写出数据

package test.stream;

import java.io.*;

public class StreamTest {
    public static void main(String[] args) {
        File f = new File("d:/a.txt");
        byte[] buf = {88, 89};
        try {
            FileOutputStream fos = new FileOutputStream(f);
            fos.write(buf);
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流

Reader字符输入流
Writer字符输出流
专门用于字符的形式读取和写入数据

FileReader 是Reader子类，以FileReader 为例进行文件读取

package test.stream;

import java.io.*;

public class StreamTest {
    public static void main(String[] args) {
        File f = new File("d:/a.txt");
        try (FileReader fr = new FileReader(f)) {
            char[] all = new char[(int)f.length()];
            fr.read(all);
            for (char ch : all) {
                System.out.println(ch);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileWriter 是Writer的子类，以FileWriter 为例把字符串写入到文件

package test.stream;

import java.io.*;

public class StreamTest {
    public static void main(String[] args) {
        File f = new File("d:/a.txt");
        try (FileWriter fw = new FileWriter(f)) {
            String data = "hello world!";
            char[] all = data.toCharArray();
            fw.write(all);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

缓冲流

缓冲流必须创建在一个已经存在的流上。

缓存字符输入流 BufferedReader 可以一次读取一行数据。

package test.stream;

import java.io.*;

public class StreamTest {
    public static void main(String[] args) {
        File f = new File("d:/a.txt");
        try (
                FileReader fr = new FileReader(f);
                BufferedReader br = new BufferedReader(fr);
        ) {
            while (true) {
                String line = br.readLine();
                if (line == null) {
                    break;
                }
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

PrintWriter 缓存字符输出流，可以一次写出一行数据

package test.stream;

import java.io.*;

public class StreamTest {
    public static void main(String[] args) {
        File f = new File("d:/a.txt");
        try (
                FileWriter fr = new FileWriter(f);
                PrintWriter pw = new PrintWriter(fr);
        ) {
            pw.println("你是？");
            pw.println("hehe");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

有的时候，需要立即把数据写入到硬盘，而不是等缓存满了才写出去。这时候就需要用到flush

package test.stream;

import java.io.*;

public class StreamTest {
    public static void main(String[] args) {
        File f = new File("d:/a.txt");
        try (
                FileWriter fr = new FileWriter(f);
                PrintWriter pw = new PrintWriter(fr);
        ) {
            pw.println("你是？");
            pw.flush();
            pw.println("hehe");
            pw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

数据流

使用数据流的writeUTF()和readUTF() 可以进行数据的格式化顺序读写
如本例，通过DataOutputStream 向文件顺序写出布尔值，整数和字符串。然后再通过DataInputStream 顺序读入这些数据。

注：要用DataInputStream 读取一个文件，这个文件必须是由DataOutputStream 写出的，否则会出现EOFException，因为DataOutputStream 在写出的时候会做一些特殊标记，只有DataInputStream 才能成功的读取。

package test.stream;

import java.io.*;

public class StreamTest {
    public static void main(String[] args) {
        write();
        read();
    }

    private static void read() {
        File f = new File("d:/a.txt");
        try (
                FileInputStream fis = new FileInputStream(f);
                DataInputStream dis = new DataInputStream(fis);
        ) {
            boolean b = dis.readBoolean();
            int i = dis.readInt();
            String str = dis.readUTF();

            System.out.println("读取到布尔值:" + b);
            System.out.println("读取到整数:" + i);
            System.out.println("读取到字符串:" + str);

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    private static void write() {
        File f = new File("d:/a.txt");
        try (
                FileOutputStream fos = new FileOutputStream(f);
                DataOutputStream dos = new DataOutputStream(fos);
        ) {
            dos.writeBoolean(true);
            dos.writeInt(300);
            dos.writeUTF("123 this is gareen");
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

对象流

对象流指的是可以直接把一个对象以流的形式传输给其他的介质，比如硬盘

一个对象以流的形式进行传输，叫做序列化。该对象所对应的类，必须是实现Serializable接口

创建一个Hero对象，设置其名称为garen。
把该对象序列化到一个文件garen.lol。
然后再通过序列化把该文件转换为一个Hero对象

注：把一个对象序列化有一个前提是：这个对象的类，必须实现了Serializable接口

package test.stream;

import java.io.*;

public class StreamTest {
    public static void main(String[] args) {
        Hero h = new Hero();
        h.name = "zed";
        h.hp = 10;
        File f = new File("d:/a.txt");
        try (
                // 创建对象输出流
                FileOutputStream fos = new FileOutputStream(f);
                ObjectOutputStream oos = new ObjectOutputStream(fos);
                // 创建对象输入流
                FileInputStream fis = new FileInputStream(f);
                ObjectInputStream ois = new ObjectInputStream(fis);
        ) {
            oos.writeObject(h);
            Hero h_2 = (Hero) ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

package test.stream;

import java.io.Serializable;

public class Hero implements Serializable {
    private static final long serialVersionUID = 1L;
    public String name;
    public float hp;

}