Java-IO类记录

Java-IO类记录

一、前言

• JDK：1.8

参考：

https://docs.oracle.com/javase/8/docs/api/index.html

https://docs.oracle.com/javase/tutorial/

https://docs.oracle.com/javase/tutorial/essential/io/index.html

二、I/O流 (I/O Streams)

1.字节流 (Byte Streams)

• 处理原始二进制数据的I / O

• 程序使用字节流执行8位字节的输入和输出。所有字节流类均来自 InputStream和 OutputStream。

• 所有其他流类型都建立在字节流上。

InputStream	OutputStream
FileInputStream	FileOutputStream
ByteArrayInputStream	ByteArrayOutputStream
ObjectInputStream	ObjectOutputStream
FilterInputStream	FilterOutputStream
PipedInputStream	PipedOutputStream
InputStream	OutputStream
AudioInputStream
SequenceInputStream
StringBufferInputStream

2.字符流(Character Streams)

• 处理字符数据的I / O，自动处理与本地字符集之间的转换

• Java平台使用Unicode约定存储字符值。字符流I / O自动将此内部格式与本地字符集转换。在西方语言环境中，本地字符集通常是ASCII的8位超集。
• 所有字符流类均源于 Reader和 Writer。
• 字符流通常是字节流的“包装器”。字符流使用字节流执行物理I / O，而字符流则处理字符和字节之间的转换。
• 字节到字符“桥梁”的流： InputStreamReader和 OutputStreamWriter。
• 面向行的I/O：BufferedReader和 PrintWriter 【在结尾处带有行终止符的字符串。换行符可以是回车符/换行符（"\r\n"），单个回车符（"\r"）或单个换行符（"\n"）。】

Reader	Writer
InputStreamReader	OutputStreamWriter
FileReader extends InputStreamReader	FileWriter extends OutputStreamWriter
StringReader	StringWriter
CharArrayReader	CharArrayWriter
FilterReader	FilterWriter
PipedReader	PipedWriter
BufferedReader	BufferedWriter
	PrintWriter

3.缓存流(Buffered Streams)

• 通过减少对本机API的调用次数来优化输入和输出

• 我们看到的大多数示例都使用无缓冲的 I / O。这意味着每个读取或写入请求均由底层操作系统直接处理。由于每个这样的请求通常会触发磁盘访问，网络活动或其他相对复杂的操作，因此这可能会使程序的效率大大降低。
• BufferedInputStream与 BufferedOutputStream创建缓冲字节流，而 BufferedReader与 BufferedWriter创建缓冲字符流

4.数据流(Data Streams)

• 处理原始数据类型和String值的二进制I / O

• 数据流支持基本数据类型值的二进制I / O（ ，boolean，char，byte，short，int，long，float和double），以及字符串值。
• 所有数据流都实现 DataInput接口或 DataOutput接口。

5.对象流(Object Streams)

• 处理对象的二进制I / O

• 大多数（但不是全部）标准类支持其对象的序列化。
• 对象流类是 ObjectInputStream和 ObjectOutputStream。这些类实现 ObjectInput和 ObjectOutput，它们是DataInput和DataOutput的子接口。
• 这意味着数据流中涵盖的所有原始数据I / O方法也都在对象流中实现。因此，对象流是包含原始值和对象值的混合。

三、其它

1.文件I/O

• 文件I/O (File I/O (Featuring NIO.2))

2.代码示例

package com.demo.io;

import java.io.*;

public class IODemo {

    InputStream inputStream = null;
    OutputStream outputStream = null;
    BufferedInputStream bufferedInputStream = null;
    InputStreamReader inputStreamReader = null;
    OutputStreamWriter outputStreamWriter = null;
    BufferedReader bufferedReader = null;
    PrintWriter printWriter = null;
    BufferedWriter bufferedWriter = null;

    public static void main(String[] args) {
        IODemo ioDemo = new IODemo();
        String inputPath = "E://input.txt";
        String inputPathUTF8 = "E://input-utf8.txt";
        String outputPath = "E://output.txt";
        try {

            ioDemo.copyFileByByteStream(inputPath, outputPath);
            // ioDemo.readUTF8FileByByteStream(inputPathUTF8);
            // ioDemo.readFileByCharacterStreamsOfPrintWriter(inputPath, outputPath);
            // ioDemo.readFileByCharacterStreams(inputPath);
            // ioDemo.writeFileByCharacterStreams("你好，hello", outputPath);

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            ioDemo.close();
        }
    }

    /**
     * 字节流拷贝文件
     * @param inputPath 输入文件路径
     * @param outputPath 输出文件路径
     * */
    public void copyFileByByteStream(String inputPath, String outputPath) throws IOException {
        inputStream = new FileInputStream(new File(inputPath));
        outputStream = new FileOutputStream(new File(outputPath));
        int b = 0;
        while ((b = inputStream.read()) != -1){
            outputStream.write(b);
        }
        System.out.println("copyFileByByteStream 运行完成");
    }

    /**
     * 字节流读取文件内容(格式UTF-8)
     * (英文占用一个字节，GBK 中文占用两个字节，UTF-8 中文占用3个字节，如果当中某个中文只读了一个字节，就会导致中文乱码)
     * 判断当前字节的数据是否是中文（判断是否是标准ASCII表中，0~127之间）
     * 参考：https://www.2cto.com/kf/201709/680188.html
     * @param inputPath 输入TXT路径
     * */
    public void readUTF8FileByByteStream(String inputPath) throws IOException {
        inputStream = new FileInputStream(new File(inputPath));
        bufferedInputStream = new BufferedInputStream(inputStream);
        int b = 0;
        int b2 = 0;
        int b3 = 0;
        while ((b = bufferedInputStream.read()) != -1){
            if(!(b>=0 && b<128)){
                b2 = bufferedInputStream.read();
                b3 = bufferedInputStream.read();
                System.out.println(new String(new byte[] {(byte) b, (byte) b2, (byte) b3} ));
            }else{
                System.out.println((char) b);
            }
        }
        System.out.println("readFileByByteStream 运行完成");
    }

    /**
     * 字符流拷贝文件
     * (字节流和字符流的桥梁)
     * @param inputPath 输入TXT路径
     * @param outputPath 输出TXT路径
     * */
    public void readFileByCharacterStreamsOfPrintWriter(String inputPath, String outputPath) throws IOException {
        bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(inputPath), "GBK"));
        printWriter = new PrintWriter(new FileWriter(outputPath));
        String s = "";
        while ((s = bufferedReader.readLine()) != null){ // 缓冲字符流进行行读取
            printWriter.println(s);
        }
        System.out.println("readFileByCharacterStreamsOfPrintWriter 运行完成");
    }

    /**
     * 字符流读取文件内容
     * (字节流和字符流的桥梁)
     * @param inputPath 输入TXT路径
     * */
    public void readFileByCharacterStreams(String inputPath) throws IOException {
        bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(inputPath), "GBK"));
        String s = "";
        while ((s = bufferedReader.readLine()) != null){ // 缓冲字符流进行行读取
            System.out.println(s);
        }
        System.out.println("readFileByCharacterStreams 运行完成");
    }

    /**
     * 字符流写入文件内容
     * @param content 输出文本内容
     * @param outputPath 输出TXT路径
     * */
    public void writeFileByCharacterStreams(String content, String outputPath) throws IOException {
        bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outputPath), "GBK"));
        bufferedWriter.write(content);
        bufferedWriter.newLine(); //  空行/ 换行
        System.out.println("writeFileByCharacterStreams 运行完成");
    }

    /**
     * 关闭流
     * */
    public void close(){
        try {
            if(inputStream != null){
                inputStream.close();
            }
            if(outputStream != null){
                outputStream.close();
            }
            if(bufferedInputStream != null){
                bufferedInputStream.close();
            }
            if(inputStreamReader != null){
                inputStreamReader.close();
            }
            if(outputStreamWriter != null){
                outputStreamWriter.close();
            }
            if(bufferedReader != null){
                bufferedReader.close();
            }
            if(printWriter != null){
                printWriter.close();
            }
            if(bufferedWriter != null){
                bufferedWriter.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("close 流关闭完成");
    }

}