Java基础—File、InputStream、OutputStream、Reader、Writer

关注

原创 2025-07-24 21:52:07 783 阅读 AI 写同款· GEO 优化 ›

浅谈InputStream 网络传输方面总会碰到将某种格式的文本或者图片等转幻成数据流的方式来传输，那到底是什么原理呢阅读详情

1. File类

构造函数：
File(File parent, String child) 根据父抽象路径名和子路径名字符串创建一个新的File实例。
File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
File(String parent, String child) 根据父路径名字符串和子路径名字符串创建一个新的File实例。

File API：
boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
boolean createNewFile() 当且仅当具有该抽象路径名的文件不存在时，以原子方式创建一个新的空文件。
boolean mkdirs() 创建以此抽象路径名命名的目录，包括任何必需但不存在的父目录。
boolean delete() 删除此抽象路径名表示的文件或目录。
boolean renameTo(File dest) 重命名此抽象路径名表示的文件。

long length() 返回此抽象路径名表示的文件的长度。
boolean isFile() 测试此抽象路径名表示的文件是否为普通文件。
boolean isDirectory() 测试此抽象路径名表示的文件是否是一个目录。

String getPath() 将此抽象路径名转换为一个路径名字符串。比如 image\temp\test.txt，D:\image\temp\test.txt。
String getName() 返回由此抽象路径名表示的文件或目录的名称，比如 test.txt。	
String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
String getParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。比如 image\temp，D:\image\temp。

2. 基于字节的I/O操作

2.1 基于字节的I/O操作类的层次结构

InputStream（C）抽象类,表示字节输入流所有类的超类。
    |
    |-- FileInputStream（C）文件字节输入流。 
    |
	|-- ByteArrayInputStream（C）字节数组输入流，包含一个内部缓冲区，其中包含可以从流中读取的字节。
    |
    |-- ObjectInputStream（C）只有实现 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流读取。
 	|
    |-- FilterInputStream（C）容纳其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。
    |			| 
    |			|-- BufferedInputStream（C）字节缓冲输入流。
    |
    |-- PipedInputStream（C）管道字节输入流。        


OutputStream（C）抽象类,表示字节输出流所有类的超类。
    |
    |-- FileOutputStream（C）文件字节输出流。
	|
    |-- ByteArrayOutputStream（C）字节数组输出流，将数据写入一个字节数组；缓冲区在数据写入时自动增长。
    |
    |-- ObjectOutputStream（C）只有实现 java.io.Serializable 接口的对象才能写入流中。
    |
    |-- FilterOutputStream（C）容纳其他一些输出流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。
    |			|
    |			|--BufferedOutputStream（C）字节缓冲的输出流。
    |
    |-- PipedOutputStream（C）管道字节输出流。

2.2 InputStream、OutputStream

InputStream（C）抽象类,字节输入流所有类的超类。
API：
abstract int read() 从输入流中读取数据的下一个字节。
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
int read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组。
void close() 关闭此输入流并释放与该流关联的所有系统资源。


OutputStream（C）抽象类,字节输出流所有类的超类。
API：
abstract void write(int b) 将指定的字节写入此输出流。
void write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。
void write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
void flush() 刷新此输出流并强制写出所有缓冲的输出字节。
void close() 关闭此输出流并释放与此流有关的所有系统资源。

2.3 FileInputStream、FileOutputStream

FileInputStream（C）文件字节输入流。  
构造函数：
FileInputStream(File file) 
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
FileInputStream(String name) 
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

API：
继承 InputStream 抽象类方法。


FileOutputStream（C）文件字节输出流。 
构造函数：
FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(File file, boolean append) 
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。append 如果为 true，则将字节从文件末尾处开始写入，如果为 false 则将字节从文件开始处写入。
FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(String name, boolean append) 
创建一个向具有指定 name 的文件中写入数据的输出文件流。append 如果为 true，则将字节从文件末尾处开始写入，如果为 false 则将字节从文件开始处写入。

API：
继承 OutputStream 抽象类方法。

2.4 ByteArrayInputStream、ByteArrayOutputStream

ByteArrayInputStream（C）字节数组输入流，包含一个内部缓冲区，其中包含可以从流中读取的字节。
构造函数：
ByteArrayInputStream(byte[] buf) 创建一个 ByteArrayInputStream，使用 buf 作为其缓冲区数组。
ByteArrayInputStream(byte[] buf, int offset, int length) 创建 ByteArrayInputStream，使用 buf 作为其缓冲区数组。

API：
继承 InputStream 抽象类方法。
void close() 关闭 ByteArrayInputStream 无效。关闭此流后仍可被调用，而不会产生任何IOException。


ByteArrayOutputStream（C）字节数组输出流，将数据写入一个字节数组；缓冲区在数据写入时自动增长。
构造函数：
ByteArrayOutputStream() 创建一个新的 byte 数组输出流。
ByteArrayOutputStream(int size) 创建一个新的 byte 数组输出流，它具有指定大小的缓冲区容量（以字节为单位）。

API：
继承 OutputStream 抽象类方法。 
byte[] toByteArray() 创建一个新分配的 byte 数组。
int size() 返回缓冲区的当前大小。 
String toString() 使用平台默认的字符集，通过解码字节将缓冲区内容转换为字符串。
String toString(String charsetName) 使用指定的 charsetName，通过解码字节将缓冲区内容转换为字符串。 
void close() 关闭 ByteArrayOutputStream 无效。在关闭此流后仍可被调用，而不会产生任何 IOException。

2.5 ObjectInputStream、ObjectOutputStream

ObjectInputStream（C）只有实现 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流读取。
构造函数：
ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的 ObjectInputStream。

API：
继承 InputStream 抽象类方法。
Object readObject() 从 ObjectInputStream 读取对象。


ObjectOutputStream（C）只有实现 java.io.Serializable 接口的对象才能写入流中。
构造函数：
ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream。

API：
继承 OutputStream 抽象类方法。    
void writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。

2.6 BufferedInputStream、BufferedOutputStream

BufferedInputStream（C）字节缓冲输入流。
构造函数：
BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。默认缓冲区为8192字节。
BufferedInputStream(InputStream in, int size) 
创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

API：
继承 InputStream 抽象类方法。


BufferedOutputStream（C）字节缓冲的输出流。
构造函数：
BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。默认缓冲区为8192字节。
BufferedOutputStream(OutputStream out, int size) 
创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。

API：
继承 OutputStream 抽象类方法。

2.7 PipedInputStream、PipedOutputStream

PipedInputStream（C）管道字节输入流。
构造函数：
PipedInputStream() 创建尚未连接的 PipedInputStream。
PipedInputStream(int pipeSize) 创建一个尚未连接的 PipedInputStream，并对管道缓冲区使用指定的管道大小。
PipedInputStream(PipedOutputStream src) 创建 PipedInputStream，使其连接到管道输出流 src。
PipedInputStream(PipedOutputStream src, int pipeSize) 
创建一个 PipedInputStream，使其连接到管道输出流 src，并对管道缓冲区使用指定的管道大小。

API：
继承 InputStream 抽象类方法。


PipedOutputStream（C）管道字节输出流。
构造函数：
PipedOutputStream() 创建尚未连接到管道输入流的管道输出流。
BufferedOutputStream(OutputStream out, int size) 
PipedOutputStream(PipedInputStream snk) 创建连接到指定管道输入流的管道输出流。

API：
继承 OutputStream 抽象类方法。

2.8 示例

1、从文件读写对象：
FileInputStream fis = new FileInputStream("t.tmp");
ObjectInputStream ois = new ObjectInputStream(fis);
BufferedInputStream bis = new BufferedInputStream(ois);

FileOutputStream fos = new FileOutputStream("t.tmp");
ObjectOutputStream oos = new ObjectOutputStream(fos);
BufferedOutputStream bos = new BufferedOutputStream(oos);

2、从内存读写对象：
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(object);
oos.flush();
byte[] bytes = baos.toByteArray();
oos.close();

ByteArrayInputStream bais = ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
Object object = ois.readObject()

3、读文件到内存
try (FileInputStream fis = new FileInputStream("t.tmp");
     BufferedInputStream bis = new BufferedInputStream(fis);
     ByteArrayOutputStream baos = new ByteArrayOutputStream();) {

     byte[] temp = new byte[8192];
     int length;
     while ((length = bis.read(temp)) != -1) {
	 	baos.write(temp, 0, length);
     }
     byte[] bytes = baos.toByteArray();
     System.out.println(new String(bytes, "UTF-8"));
} catch (Exception e) {
    e.printStackTrace();
}

3. 基于字符的I/O操作

3.1 基于字符的I/O操作类的层次结构

Reader（C）抽象类,读取字符流。
	|
    |-- InputStreamReader（C）字节转字符输入流。
    |	
    |-- BufferedReader（C）字符缓冲输入流。 
    |	
    |-- PipedReader（C）管道字符输入流。
	 

Writer（C）抽象类,写入字符流。
	|
    |-- OutputStreamWriter（C）字符转字节输出流。
    |   
    |-- PrintWriter（C）字符缓冲输出流。
    |   
    |-- PipedWriter（C）管道字符输出流。

3.1 Reader、Writer

Reader（C）抽象类,读取字符流。
API：
int read() 读取单个字符。
int read(char[] cbuf) 将字符读入数组。
abstract int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。
abstract void close() 关闭该流并释放与之关联的所有资源。


Writer（C）抽象类,写入字符流。
API：
Writer append(CharSequence csq) 附加指定的字符序列。
Writer append(CharSequence csq, int start, int end) 附加指定字符序列的子序列。
void write(int c) 写入单个字符。
void write(char[] cbuf) 写入字符数组。
abstract void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。
void write(String str) 写入字符串。
void write(String str, int off, int len) 写入字符串的某一部分。
abstract void flush() 刷新该流的缓冲。
abstract void close() 关闭此流，但要先刷新它。

3.2 InputStreamReader、OutputStreamWriter

InputStreamReader（C）字节转字符输入流。
构造函数：
InputStreamReader(InputStream in) 创建一个使用默认字符集的 InputStreamReader。
InputStreamReader(InputStream in, String charsetName) 创建使用指定字符集的 InputStreamReader。

API：
继承 Reader 抽象类方法。
String getEncoding() 返回此流使用的字符编码的名称。


OutputStreamWriter（C）字符转字节输出流。
构造函数：
OutputStreamWriter(OutputStream out) 创建使用默认字符编码的 OutputStreamWriter。
OutputStreamWriter(OutputStream out, String charsetName) 创建使用指定字符集的 OutputStreamWriter。   

API：  
继承 Writer 抽象类方法。
String getEncoding() 返回此流使用的字符编码的名称。

3.3 BufferedReader、BufferedWriter

BufferedReader（C）字符缓冲输入流。   
构造函数：
BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流。默认缓冲区为8192字节。
BufferedReader(Reader in, int sz) 创建一个使用指定大小输入缓冲区的缓冲字符输入流。

API：
继承 Reader 抽象类方法。
String readLine() 读取一个文本行。


BufferedWriter（C）字符缓冲输出流。
构造函数：
BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。默认缓冲区为8192字节。
BufferedWriter(Writer out, int sz) 创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。

API：
继承 Writer 抽象类方法。
void newLine() 写一个换行符。

3.4 PipedReader、PipedWriter

PipedReader（C）管道字符输入流。
构造函数：
PipedReader() 创建尚未连接的 PipedReader。
PipedReader(int pipeSize) 创建一个尚未连接的 PipedReader，并对管道缓冲区使用指定的管道大小。
PipedReader(PipedWriter src) 创建连接到传送 writer src 的 PipedReader。
PipedReader(PipedWriter src, int pipeSize) 
创建一个 PipedReader，使其连接到管道 writer src，并对管道缓冲区使用指定的管道大小。

API：
继承 Reader 抽象类方法。


PipedWriter（C）管道字符输出流。
构造函数：
PipedWriter() 创建一个尚未连接到传送 reader 的传送 writer。
PipedWriter(PipedReader snk) 创建传送 writer，使其连接到指定的传送 reader。 

API：  
继承 Writer 抽象类方法。

3.5 示例

FileOutputStream fos = new FileOutputStream("t.tmp");
OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
BufferedWriter bw = new BufferedWriter(osw);

FileInputStream fis = new FileInputStream("t.tmp");
InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
BufferedReader br = new BufferedReader(isr);

@Test
public void readAndWrite() {
    // 文本地址
    String readFile = "1.txt";

    // 1.按行读取
    try (FileReader reader = new FileReader(readFile);
         BufferedReader br = new BufferedReader(reader)) {

        StringBuilder result = new StringBuilder();
        // 读取
        String line = "";
        while((line = br.readLine()) != null) {
            result.append(line);
        }
        // 注：原文本有换行，按此方法读出的结果是没有换行的
        System.out.println(result);
    } catch (Exception e) {
        e.printStackTrace();
    }

    // 2.按字符读取
    try (FileReader reader = new FileReader(readFile);
         BufferedReader br = new BufferedReader(reader)) {

        StringBuilder result = new StringBuilder();
        // 读取
        char[] buf = new char[1024];
        int len = 0;
        while((len = br.read(buf)) != -1) {
            String str = new String(buf, 0 , len);
            result.append(str);
        }
        // 注：此方法读出的结果是完全的
        System.out.println(result);
    } catch (Exception e) {
        e.printStackTrace();
    }

    // 3.写
    // 如果 2.txt 没有创建就会自动创建
    try (FileWriter fw = new FileWriter("2.txt");
         BufferedWriter bw = new BufferedWriter(fw)) {

        bw.write("第一种写");
        bw.newLine(); // 自动根据操作系统选择换行符

        char[] buf = new char[]{'第','二','种','写'};
        bw.write(buf, 0, 4);

        bw.append("第")
                .append("三")
                .append("种")
                .append("写")
                .flush();
    } catch (Exception e) {
        e.printStackTrace();
    }
}