首页 🍄Java

当不同的介质之间有数据交互的时候,JAVA就使用流来实现。
数据源可以是文件,还可以是数据库,网络甚至是其他的程序

输入流:InputStream
输出流:OutputStream

文件输入流:FileInputStream
文件输出流:FileOutputStream

字节流:

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;

}



文章评论

目录