Java-I/O流

总结

I/O流分类

• 按照操作单元划分，字节I/O系统和字符I/O系统。
• 按照流的流向分，可以将流分为输入流和输出流

所有超类

• java.io.InputStream
• java.io.OutputStream
• java.io.Reader
• java.io.Writer

常用流类结构

按操作方式分类结构图：
按操作对象分类结构图

流特点

带Buffered的性能高，使用了缓存，将数据保存在内存中，一定量时再进行写入磁盘，提高了效率。

字节流 InputStream OutputStream

FileInputStream/FileOutputStream

public static void writeFile() {
    FileOutputStream fos = null;
    char a = 'A';
    char b = '中';
    String s = "Hello 中国";
    try {
        fos = new FileOutputStream("data1.txt");
        fos.write(a);
        // fos.write(b); // 中文占两个字节，虽然write接收int，但实际只输出低位一个字节，故该句会引起乱码
        fos.write(String.valueOf(b).getBytes());
        fos.write(s.getBytes()); // Project Encoding为UTF-8,故以utf-8编码解码字节 data1.txt根据字节特征识别为utf-8格式，故不会乱码
        fos.write(s.getBytes("gbk")); // 以gbk编码解码字节，由于以包含utf-8字节，再放入gbk编码字节，data1.txt无法识别编码，故会乱码
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (fos != null) {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public static void readFile() {
    FileInputStream fis = null;
    try {
        // 可以指定全路径，也可以相对路径（相对于工程根目录）
        fis = new FileInputStream("data.txt");
        byte[] bytes = new byte[10];
        // 读取出来的就是硬盘上该文件内容的字节序列
        int v = fis.read(bytes);
        while (v != -1) {
            // 输出到控制台，默认以ANSI编码解析，如果Studio控制台指定了编码格式，则以对应编码格式解析
            System.out.write(bytes, 0, v);
            v = fis.read(bytes);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (fis != null) {
                fis.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

DataInputStream/DataOutputSrream

public static void binaryRead() {
    FileInputStream fis = null;
    DataInputStream dis = null;
    try {
        fis = new FileInputStream("data.txt");
        dis = new DataInputStream(fis);
        // 读取顺序必须完全一致
        byte a = dis.readByte();
        boolean flag = dis.readBoolean();
        int b = dis.readInt();
        float f = dis.readFloat();
        String str = dis.readUTF(); // 通过UTF-8编码解析基础输入流的字节
        System.out.println(a);
        System.out.println(flag);
        System.out.println(b);
        System.out.println(f);
        System.out.println(str);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (dis != null) {
            try {
                dis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

public static void binaryWrite() {
    byte a = 1;
    boolean flag = true;
    int b = 10;
    float f = 30.12f;
    String str = "Hello 中国";
    FileOutputStream fos = null;
    DataOutputStream dos = null;
    try {
        fos = new FileOutputStream("data.txt");
        dos = new DataOutputStream(fos);
        dos.writeByte(a);
        dos.writeBoolean(flag);
        dos.writeInt(b);
        dos.writeFloat(f);
        dos.writeUTF(str); // 使用 UTF-8编码将一个字符串写入基础输出流
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (dos != null) {
            try {
                // 只需关外层流
                dos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

PipedInputStream/PipedOutputStream

public class Test {
    public static void main(String[] args) {
        /**
         * 流程
         * 1 建立输入输出流
         * 2 绑定输入输出流
         * 3 向缓冲区写数据
         * 4 读取缓冲区数据
         */
        PipedOutputStream pos = new PipedOutputStream();
        PipedInputStream pis = new PipedInputStream();
        try {
            pos.connect(pis); // 接通输入和输出形成管道
            Producer producer = new Producer(pos);
            Consumer consumer = new Consumer(pis);
            producer.start();
            consumer.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
/**
 * 生产者线程
 */
class Producer extends Thread {
    // 输出流
    private PipedOutputStream out = new PipedOutputStream();

    // 构造方法
    public Producer(PipedOutputStream out) {
        this.out = out;
    }

    @Override
    public void run() {
        writeMessage();
    }

    private void writeMessage() {
        StringBuilder sb = new StringBuilder("Hello World!!!");
        try {
            out.write(sb.toString().getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

/**
 * 消费线程
 */
class Consumer extends Thread {
    //输入流, 默认缓冲区大小为1024
    private PipedInputStream in = new PipedInputStream();

    //构造方法
    public Consumer(PipedInputStream in) {
        this.in = in;
    }

    @Override
    public void run() {
        readMessage();
    }

    private void readMessage() {
        byte[] buf = new byte[1024];
        try {
            int len = in.read(buf);
            System.out.println("缓冲区的内容为: " + new String(buf, 0, len));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符流

InputStreamReader/OutputStreamWriter

private static void charRead() {
    FileInputStream fis = null;
    InputStreamReader isr = null;
    try {
        fis = new FileInputStream("data.txt");
        // 默认使用系统设定编码，也可指定编码，eg：使用utf-8编码解析，如果写入和读取编码不一致，很可能乱码
        isr = new InputStreamReader(fis, "UTF-8");
        char[] chars = new char[10];
        int count = isr.read(chars);
        while (count != -1) {
            System.out.print(new String(chars, 0, count));
            count = isr.read(chars);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (isr != null) {
            try {
                isr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

private static void charWrite() {
    FileOutputStream fos = null;
    OutputStreamWriter osw = null;
    try {
        fos = new FileOutputStream("data.txt");
        osw = new OutputStreamWriter(fos);
        osw.write("Hello 中");
        osw.write('国');
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (osw != null) {
            try {
                osw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

BufferedReader/BufferedWriter

public static void bufferReadWrite() {
    // 读取用户从控制台的输入，并写入文件，直到用户输入了ok为止
    String input = null;
    BufferedReader br = null;
    BufferedWriter bw = null;
    String filePath = "data.txt";
    br = new BufferedReader(new InputStreamReader(System.in));
    try {
        bw = new BufferedWriter(new OutputStreamWriter(
                new FileOutputStream(filePath)));
    } catch (FileNotFoundException e1) {
        e1.printStackTrace();
    }
    do {
        System.out.print("请输入一行文字：");
        try {
            input = br.readLine();
            bw.write(input);
            bw.newLine();
        } catch (IOException e) {
            e.printStackTrace();
        }

    } while (!input.equals("ok"));

    try {
        br.close();
        bw.close();
    } catch (IOException e) {
        e.printStackTrace();
    }

    // 从文件中读取内容并显示
    try {
        br = new BufferedReader(new InputStreamReader(new FileInputStream(
                filePath)));
        input = br.readLine();
        while (input != null) {
            System.out.println(input);
            input = br.readLine();
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

System.out/System.in PrintStream/InputStream

out就是PrintStream类，其print方法都是通过BufferedWriter实现的。