beanshell必备：I/O流使用简单总结

节点流：直接对File类进行操作的文件流

 

 *     流的体系结构：     抽象基类             节点流(或文件流)            缓冲流(处理流的一种)
 *     字节输入流         InputStream        FileInputStream          BufferedInputStream
 *     字节输出流         OutputStream       FileOutputStream         BufferedOutputStream
 *     字符输入流         Reader             FileReader               BufferedReader
 *     字符输出流         Writer             FileWriter               BufferedWriter
 * 
 *     字符流只能处理字符，字节流能处理图片，二进制文件

 

 

包装流（处理流）：用来修饰节点流

　　比如：缓冲流加速；

　　关闭的时候，只需要关闭外层流即可，也就是关闭包装流即可（真正处理读写的是节点流，处理流（包装流）只是一个包装，但是重写了close方法，只要关闭包装流就会自动将节点流关闭）

 

 

转换流：进行编码和解码

 

https://www.cnblogs.com/zsben991126/p/11874832.html

---------------------------------------------------

流的分类：

　　操作数据单位：字节流 （8bit） ，二进制文件，字符流（字符） ，文本文件

　　流向：输入流、输出流

　　流的角色：节点流，处理流/包装流

 

https://blog.csdn.net/weixin_52574640/article/details/127774908

----------------------------------------------------

 

字节流

|-InputStream抽象类
    |-FileInputStream，文件字节输入流；属于节点流
    |-ByteArrayInputStream，字节数组输入流；属于节点流
    |-ObjectInputStream，读取对象，即反序列化；属于包装流
|-OutputStream抽象类
    |-FileOutputStream，文件字节输出流；属于节点流
    |-ByteArrayOutputStream，字节数组输出流；属于节点流
    |-ObjectOutputStream，写入对象，即序列化；属于包装流

 

另外：还有缓冲字节输出流（BufferedOutputStream）、缓冲字节输入流（BufferedInputStream），如果非二进制文件，字节流可以转换为字符流，用缓冲字符输出/输入流即可（BufferedReader/BufferedWriter）。 

 

 

字符流

|-Reader抽象类
    |-FileReader，文件字符输入流；属于节点流
    |-BufferedReader，缓冲字符输入流；属于包装流
    |-InputStreamReader，将字节输入流转换为字符输入流；属于转换流
|-Writer抽象类
    |-FileWriter，文件字符输出流；属于节点流
    |-BufferedWriter（缓冲字符输出流；属于包装流） / PrintWriter（打印流，功能更强操作简单；属于包装流）
    |-OutputStreamWriter，将字节输出流转换字符输出流；属于转换流

 

总结：

　　用转换流（OutputStreamWriter）将字节输出流（FileOutputStream）转换为字符输出流（FileWriter），用包装流（BufferedWriter）将字符输出流（FileWriter）包装为缓冲字符输出流（BufferedWriter）

　　用转换流（InputStreamReader）将字节输入流（FileInputStream）转换为字符输入流（FileReader），用包装流（BufferedReader）将字符输入流（FileReader）包装为缓冲字符输入流（BufferedReader）

 　　

 

 

 

写内容到文件

 方法一：文件字符输出流

package com.qzcsbj.demo.commons;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @description : <描述>
 */
public class Test {
    public static void main(String[] args) throws IOException {
        String s = "hello world";
        File f = new File("d:/test.txt");
        FileWriter fw = new FileWriter(f);  // 构建一个文件字符输出流
        fw.write(s);
        fw.close();
    }
}

　　

 方法二：文件字符输出流 +  包装流（缓冲字符输出流）

package com.qzcsbj.demo.commons;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @description : <描述>
 */
public class Test {
    public static void main(String[] args) throws IOException {
        String s = "hello world";
        File f = new File("d:/test.txt");
        FileWriter fw = new FileWriter(f);  // 构建一个文件字符输出流
        BufferedWriter fb = new BufferedWriter(fw);  // 包装为缓冲字符输出流
        fb.write(s);
        fb.close();
    }
}

 

方法三：字节输出流 + 转换流（将字节输出流转换字符输出流）

package com.qzcsbj.demo.commons;

import java.io.*;

/**
 * @description : <描述>
 */
public class Test {
    public static void main(String[] args) throws IOException {
        String s = "hello world";
        File f = new File("d:/test.txt");
        FileOutputStream out = new FileOutputStream(f);  // 构建一个字节输出流对象
        Writer w  = new OutputStreamWriter(out);  // 字节输出流转成字符输出流，OutputStreanWriter是Writer的子类
        w.write(s);
        w.close();
    }
}

 

方法四：字节输出流 + 转换流（将字节输出流转换字符输出流） + 包装流

package com.qzcsbj.demo.commons;

import java.io.*;

/**
 * @description : <描述>
 */
public class Test {
    public static void main(String[] args) throws IOException {
        String s = "hello world";
        File f = new File("d:/test.txt");
        FileOutputStream out = new FileOutputStream(f);  // 构建一个字节输出流对象
        Writer w  = new OutputStreamWriter(out);  // 字节输出流转成字符输出流，OutputStreanWriter是Writer的子类
        BufferedWriter bw = new BufferedWriter(w);  // 用包装流（BufferedWriter）将字符输出流（FileWriter）包装为缓冲字符输出流（BufferedWriter）
        bw.write(s);
        bw.close();
    }
}

 

 

总结：

字节流：

　　1、可以读、写自定义大小的字节数组；byte[] buffer = new byte[1024 * 1024 * 10]; // 每次读取10M；

public class Test {
    public static final int _1MB = 1024 * 1024;

    public static byte[] allocation1 = new byte[4 * _1MB];
    public static byte[] allocation2 = new byte[4 * _1MB];
    public static byte[] allocation3 = new byte[4 * _1MB];

    public static void main(String[] args) {
    }
}

 

　　2、【推荐】如果是操作非二进制文件，可以通过转换流转换为字符流，然后用缓冲字符输入输出流（字符流无法读写二进制文件）；

　　3、如果操作二进制文件，用对象字节输入输出流；

 

文件字符流：

　　1、可以读、写自定义大小的字符数组，char[] buffer = new char[50]; // 每次读取50个字符；

　　2、【推荐】但是，最好用缓冲字符输入输出流，可以按行读、写；

       3、另外，如果是覆盖写，都用PrintWriter；如果是追加写，用FileWriter和BufferedWriter组合

 

 

 

示例【bak】：

https://www.cnblogs.com/uncleyong/p/14098538.html