从「万物皆文件」到数据流:
引言:为什么每个 Java 程序员都要把 IO 这件事想清楚
我们每天都在和文件打交道------保存一张照片、导出一份报表、读一段配置,背后都是文件操作。但文件到底是什么?操作系统是怎么把它组织起来的?Java 又是用什么方式让我们「看见」并且「操作」它的?很多人学 IO 时一头雾水,原因往往是跳过了「文件从哪来」这一层,直接扎进了 InputStream、OutputStream 的代码海里,于是各种流、各种包装类看起来像凭空冒出来的,背了又忘。
这篇文章我想换一种方式讲:先建立认知,再动手编码,最后落到实战 。也就是一个完整的「总---分---总」结构。开头我先带你从操作系统的视角把「文件、目录、路径、类型、权限」这些底层概念想透,让你明白 Java 里那一堆 API 到底在映射现实中的什么东西;中间分两大块展开,一块是 Java 用 File 类对文件「外部属性」的操作(元信息、路径、增删改名、遍历目录),另一块是文件「内部内容」的读写------也就是数据流,我会把字节流、字符流、缓冲刷新、编码解码这些最容易踩坑的地方掰开揉碎;结尾我再把整条脉络收拢,并给出几个真正能跑的小程序,把零散的知识点串成能力。
我的一个核心体会是:IO 的所有复杂度,几乎都来自「设备慢」和「编码/字节」这两件事。 你在后面看到的所有设计------缓冲区、flush、字节流转字符流、按字符读写的封装------本质上都是在为这两件事做补偿。带着这条主线读下去,你会发现那些看似繁琐的 API,其实每一层都有它非存在不可的理由。
第一部分(总):先把「文件」这件事在脑子里立起来
在写任何一行 Java 之前,我们得先回答:文件究竟是什么。把这一层想明白,后面所有的类都只是这套现实世界的「投影」。
一、文件:持久化存储的「独立保存单位」
我们保存数据时,面对的是硬盘这种持久化存储的 I/O 设备。关键在于「持久化」三个字------它意味着数据在断电之后依然存在,这正是我们选择把重要数据放进文件而不是内存的根本原因。
但即便要保存,我们也不会把成吨的数据存成一个无法分割的整体,而是把它拆成一个个独立的单位 分别保存,这个独立单位就被抽象成了「文件(file)」的概念。你可以非常形象地把它想象成办公桌上的一份份真实文件------每份有自己的内容、自己的名字、自己归在哪个抽屉里。这个类比非常贴切,Java 后来那个 File 类,做的就是把「桌面上某一份文件」这件事在程序里复述一遍。
二、元信息:文件除了「内容」,还有「关于内容的信息」
一份文件除了真正的数据内容之外,还附带着一部分不作为数据本身存在 的信息,比如文件名、文件类型、文件大小、创建时间等。这部分信息被称为文件的元信息(metadata)。
这里有一个值得体会的观点:「文件的内容」和「文件的元信息」是两个维度的东西。 我们后面会看到,Java 对文件的操作天然分成了两半------一半专门折腾元信息和路径(用 File 类),另一半才负责往内容里读写数据(用各种流)。课件里也明确点出,讲 File 这一节「只涉及元信息、路径的操作,暂不涉及内容读写」,正是沿用了这个划分。理解了这条边界,你就不会在 File 类里苦苦寻找「怎么读出一行字」的方法了------那本来就不是它的职责。
三、目录与树形结构:当文件多了,就需要「管理者」
文件一旦多起来,杂乱地堆在一起就没法管理了。于是人们需要给文件做系统化的组织,一种最合乎直觉的方案应运而生:按层级结构组织 ------也就是数据结构里学过的树形结构。
有了树,就需要一种专门存放「管理信息」的特殊文件,这就是我们平时所说的文件夹(folder)/ 目录(directory) 。换句话说,目录本质上也是一种文件,只不过它装的不是业务数据,而是「我下面有哪些孩子」的组织信息。这一点很关键,它直接解释了后面遍历目录为什么要用递归 / 深度优先遍历:因为文件系统本身就是一棵树,遍历一棵树,递归是天然且最自然的写法。
四、路径:如何在树里唯一地定位一个文件
树有了,新问题来了:怎么描述「我要的是这棵树上的哪一个结点」?计算机科学家给出的答案,正是借用了树的性质------树中的每个结点,都可以被一条从根出发、一路走到该结点的路径所唯一描述。 这种从根出发、完整描述到目标结点的方式,就是绝对路径(absolute path)。
而除了从根出发,我们也可以从任意一个当前所在的结点 出发去描述另一条路,这就是相对路径(relative path)------它是「相对于当前所在结点」的一条路。
我的理解:绝对路径和相对路径不是两种不同的文件,而是同一种东西的两种「说法」。绝对路径像是给出「从市中心到你家的完整路线」,走到哪都不会错;相对路径像是「从你现在的位置往东走两百米」,省字、灵活,但它的含义依赖于「你现在站在哪」。这也埋下了一个常见的坑:同一个相对路径,在程序不同的工作目录下,可能指向完全不同的文件 ,后面
File类的示例里getPath()和getAbsolutePath()的差异,正是这一点的体现。
五、文件的其他常识:类型、后缀、权限与「万物皆文件」
即使是普通文件,按保存数据的方式不同,也常被粗分为两类:文本文件 (保存被字符集编码过的文本)和二进制文件 (按标准格式保存的、非字符集编码的文件)。这里要敲个黑板:「文本文件」和「二进制文件」是两套不同的看待方式,同一个文件既能按字节读,也能按字符读------这正是后面为什么要区分字节流和字符流、为什么要谈编码的根源。
关于文件类型,还有一个容易被当成「公理」的习惯:Windows 会按文件名中的后缀(扩展名)来确定文件类型以及该类型的默认打开程序。 但这并不是通用规则------在 macOS、Unix、Linux 等系统上并没有这样的习俗,它们一般不做如此依赖后缀的精确分类。把「后缀决定类型」当作理所当然,是很多新手从 Windows 转去 Linux 时困惑的来源之一,其实它只是一个平台约定而已。
文件既然被操作系统管理,自然要按用户区分对待,于是有了权限 的概念,一般认为有可读、可写、可执行 三种。这对应了 Java 里 canRead()、canWrite() 这类方法的存在意义。
Windows 上还有一类特殊文件------快捷方式(shortcut) ,它只是对真实文件的一个「引用」而已,本身并不包含真实内容。其他系统也有类似概念,比如 软链接(soft link)。理解了「引用」这一层,你会明白:删除一个快捷方式并不会删除真实文件,正如删除软链接不会删除它的目标。
最后是一个非常重要的哲学级理念:很多操作系统为了统一接口 ,把所有 I/O 设备都抽象成了文件 ------最出名的就是 Unix / Linux 的「万物皆文件 」。键盘、显示器、网络套接字、管道......在这些系统里都被当作文件来读写。这个理念为什么重要?因为它直接解释了 Java 的 IO 体系为什么长这样:既然「一切设备皆可视为文件」,那么读一个文件、读键盘输入、读网络数据,就可以共用同一套「流」的抽象。你以后看到 System.in 也是一个 InputStream、网络连接也能拿到输入输出流,就不会再觉得奇怪了------那正是「万物皆文件」思想在 Java 里的回响。
第二部分(分·上):用 File 类操作文件的「外部」
认知建立好了,正式进入 Java。这一部分我们只操作文件的「外部属性」------元信息、路径、是否存在、是目录还是文件、创建与删除、重命名、遍历目录,不涉及文件内部内容的读写。
一、File 类:对文件(含目录)的抽象描述
Java 通过 java.io.File 类来对一个文件(注意,目录也包括在内)进行抽象描述。
这里必须先强调一个最容易被误解的点:有一个 File 对象,并不代表磁盘上真实存在这个文件。 File 对象只是「一份描述」,它描述的是「如果那个文件存在的话,它叫什么、在哪、是目录还是文件」。所以你可以在文件根本不存在的情况下 new File(...),也可以在文件不存在时调用 exists() 得到 false------这不矛盾,因为 File 只是描述,不是存在本身。想通这一点,后面很多「明明 new 了却 exists 返回 false」的困惑都会烟消云散。
两个常量属性(都依赖于操作系统):
| 类型 | 属性 | 说明 |
|---|---|---|
static String |
pathSeparator |
依赖系统的路径分隔符,String 形式 |
static char |
pathSeparator |
依赖系统的路径分隔符,char 形式 |
补充:路径分隔符在不同系统上是不同的(Windows 用
\,类 Unix 用/),File提供这两个常量,就是希望你拼路径时尽量用常量而不是硬编码,从而写出跨平台可运行的代码。
三个构造方法:
| 构造方法 | 说明 |
|---|---|
File(File parent, String child) |
由「父目录 File 对象 + 子路径」创建 |
File(String pathname) |
由文件路径创建,路径可以是绝对路径或相对路径 |
File(String parent, String child) |
由「父目录路径字符串 + 子路径」创建 |
核心方法一览(按用途分组,便于记忆):
信息查询类:
| 方法 | 说明 |
|---|---|
getParent() |
返回父目录文件路径 |
getName() |
返回纯文件名称 |
getPath() |
返回创建该 File 时所用的路径(原样返回) |
getAbsolutePath() |
返回绝对路径 |
getCanonicalPath() |
返回「修饰过」的绝对路径(规范化,消掉 .、.. 等) |
exists() |
判断真实是否存在 |
isDirectory() |
判断是否是目录 |
isFile() |
判断是否是普通文件 |
canRead() / canWrite() |
判断当前用户是否有可读 / 可写权限 |
动作执行类:
| 方法 | 说明 |
|---|---|
createNewFile() |
创建一个空文件,成功返回 true |
delete() |
删除该文件,成功返回 true |
deleteOnExit() |
标记文件将在 JVM 运行结束时 被删除 |
mkdir() |
创建该目录 |
mkdirs() |
创建该目录,必要时一并创建缺失的中间目录 |
list() |
返回目录下所有文件的「文件名」数组 |
listFiles() |
返回目录下所有「File 对象」数组 |
renameTo(File dest) |
重命名(也可视作剪切/移动) |
下面通过课件里的示例,把这几组方法逐个验证一遍,顺便点出我踩过或容易踩的坑。
二、示例逐讲
示例 1:看清 get 系列的差异(绝对路径 vs 相对路径的现实投影)
java
import java.io.File;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
File file = new File("..\\hello-world.txt"); // 并不要求该文件真实存在
System.out.println(file.getParent());
System.out.println(file.getName());
System.out.println(file.getPath());
System.out.println(file.getAbsolutePath());
System.out.println(file.getCanonicalPath());
}
}
运行结果:
text
..
hello-world.txt
..\hello-world.txt
D:\代码练习\文件示例1\..\hello-world.txt
D:\代码练习\hello-world.txt
逐行解读,这五行几乎是整个 File 类最精华的对比:
getParent()得到..------父目录路径就是「上一级」。getName()得到hello-world.txt------只剩最末端的名字。getPath()得到..\hello-world.txt------你当初传什么,它就原样还什么,它不关心文件在不在。getAbsolutePath()得到D:\代码练习\文件示例1\..\hello-world.txt------它把你当前工作目录拼到前面得到绝对路径,但注意它并没有化简那个..,路径里还带着「上跳一级」的字样。getCanonicalPath()得到D:\代码练习\hello-world.txt------它在绝对路径的基础上做了规范化处理 ,把..真正生效、消掉了。
我的理解:
getPath/getAbsolutePath/getCanonicalPath三者是「越来越真实」的递进关系。getPath是「你说了什么」,getAbsolutePath是「完整说出来但保留了你的写法」,getCanonicalPath是「经过文件系统语义修饰后的唯一真相」。当你需要把两个路径做「是否指向同一个文件」的比较时,一定要用 canonical path ,否则A\b\..\c.txt和A\c.txt看起来不同、实际却是同一个文件。
示例 2:普通文件的创建与状态判断
java
import java.io.File;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
File file = new File("hello-world.txt"); // 要求该文件不存在,才能看到完整现象
System.out.println(file.exists()); // false
System.out.println(file.isDirectory()); // false
System.out.println(file.isFile()); // false
System.out.println(file.createNewFile()); // true(创建成功)
System.out.println(file.exists()); // true
System.out.println(file.isDirectory()); // false
System.out.println(file.isFile()); // true
System.out.println(file.createNewFile()); // false(已存在,创建失败)
}
}
运行结果依次为 false false false true true false true false。
两个要点:其一,文件在「创建之前」isFile() 也是 false------呼应了「File 对象不代表真实存在」;其二,对已存在的文件 再次 createNewFile() 会返回 false 而不是报错。这个细节很有用:createNewFile() 天然带了「不存在才创建、已存在不覆盖也不报错」的语义,适合做幂等的初始化。
示例 3:文件的删除
java
import java.io.File;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
File file = new File("some-file.txt"); // 要求该文件不存在
System.out.println(file.exists()); // false
System.out.println(file.createNewFile()); // true
System.out.println(file.exists()); // true
System.out.println(file.delete()); // true(删除成功)
System.out.println(file.exists()); // false
}
}
delete() 删除成功返回 true,删完 exists() 立刻变 false,干净利落。
示例 4:deleteOnExit() 的「延迟删除」现象
java
import java.io.File;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
File file = new File("some-file.txt"); // 要求该文件不存在
System.out.println(file.exists()); // false
System.out.println(file.createNewFile()); // true
System.out.println(file.exists()); // true
file.deleteOnExit();
System.out.println(file.exists()); // true ------ 此刻文件还在!
}
}
运行结果 false true true true,但程序运行结束后,文件最终被删掉了。
我的理解:
deleteOnExit()不是「现在删」,而是「登记一条遗嘱:等 JVM 退出时再删」。它常用于临时文件------程序运行期间需要一个临时文件,但不希望跑完留下垃圾,就登记在退出时自动清理。理解「登记 vs 立即执行」的区别,是用好它的关键。
示例 5:目录的创建(单层)
java
import java.io.File;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
File dir = new File("some-dir"); // 要求该目录不存在
System.out.println(dir.isDirectory()); // false
System.out.println(dir.isFile()); // false
System.out.println(dir.mkdir()); // true(创建目录成功)
System.out.println(dir.isDirectory()); // true
System.out.println(dir.isFile()); // false
}
}
创建后 isDirectory() 变 true、isFile() 仍 false,可见目录与普通文件是互斥的两个身份。
示例 6:mkdir() 与 mkdirs() 的关键差异(多级目录)
当目录路径里含有尚不存在的中间目录时:
java
File dir = new File("some-parent\\some-dir"); // some-parent 和 some-dir 都不存在
System.out.println(dir.mkdir()); // false ------ 中间目录 some-parent 不存在,失败!
System.out.println(dir.mkdirs()); // true ------ 连中间目录一起补上,成功
用 mkdir() 时,因为中间目录 some-parent 不存在,创建失败返回 false;换成 mkdirs() 则把缺失的中间目录一并创建出来,返回 true。
我的理解与口诀:
mkdir只负责「最后一级」,mkdirs负责「把整条路都修通」 (s 可以记成 "successively"------逐级补全)。凡是要创建多层嵌套目录,无脑用mkdirs()几乎不会错。
示例 7:文件重命名 renameTo()
java
import java.io.File;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
File file = new File("some-file.txt"); // 要求 some-file.txt 存在
File dest = new File("dest.txt"); // 要求 dest.txt 不存在
System.out.println(file.exists()); // true
System.out.println(dest.exists()); // false
System.out.println(file.renameTo(dest)); // true(改名成功)
System.out.println(file.exists()); // false(原名已没了)
System.out.println(dest.exists()); // true(新名已出现)
}
}
renameTo() 成功后,原路径消失、目标路径出现,文件「搬了个家、换了个名」。
我的理解:
renameTo名义上是「改名」,实际上很多场景被当作移动 / 剪切 用------因为改名和移动在底层往往是同一个操作,目标路径完全可以指向另一个目录。课件也特意点出「也可以视为我们平时的剪切、粘贴操作」。要注意它的局限:跨磁盘分区的移动、目标已存在时的覆盖行为,在不同系统上表现并不一致,因此生产代码里要检查它的返回值,别假设一定成功。
到这里,文件的「外部」我们就能完整操作了:读元信息、判类型、创建、删除、延迟删除、改名/移动、建目录、列目录。
第三部分(分·下):读写文件内容 ------ 数据流
上一节我们碰的都是文件的「壳」。这一节要钻进文件内部,读写真正的数据,也就是数据流(Stream) 。我先抛出贯穿全节的两条主线:一是数据以「字节」为单位流动,二是字符要正确显示就必须谈编码。 后面你会看到的所有「麻烦」,都源自这两点。
一、InputStream:字节输入的总抽象
InputStream 是「字节输入流」的抽象基类,负责从某个数据源读字节。核心方法:
| 方法 | 说明 |
|---|---|
int read() |
读取一个字节,返回其值;返回 -1 代表已经读完 |
int read(byte[] b) |
最多读 b.length 个字节存入 b,返回实际读到的数量;-1 代表读完 |
int read(byte[] b, int off, int len) |
从 b 的 off 位置起,最多读入 len 个字节,返回实际读到的数量;-1 代表读完 |
void close() |
关闭字节流 |
勘误与订正:课件原文把第三个方法的「最多读
len - off个字节」写错了------off是写入目标数组时的起始下标 ,len才是本次最多要读取的字节数 ,两者毫无相减关系,正确说法是「最多读入len个字节」。这是初学最容易背错的签名之一,这里特别标注,免得跟着记错。另外方法说明里的「-1 代表已经读完」中的「以及」是笔误,应为「已经」;getName写成「FIle」也是手误,正确类名是File。这些小瑕疵不影响大局,但抄写时千万别照搬。
InputStream 是抽象类,要落地必须用具体实现类。基本可以认为「每一种输入设备,都对应一个 InputStream 子类」 ------这又是「万物皆文件」的体现。我们要从文件 里读,所以用 FileInputStream。
FileInputStream 的两个构造方法:
| 构造方法 | 说明 |
|---|---|
FileInputStream(File file) |
用一个 File 对象构造文件输入流 |
FileInputStream(String name) |
用一个文件路径字符串构造文件输入流 |
读法一:按字节逐个读(直观但低效)
java
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException {
// 事先在项目目录下准备 hello.txt,内容为 "Hello"
try (InputStream is = new FileInputStream("hello.txt")) {
while (true) {
int b = is.read();
if (b == -1) { // -1 代表文件已经全部读完
break;
}
System.out.printf("%c", b);
}
}
}
}
读法二:用缓冲区批量读(推荐,IO 次数更少)
java
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException {
try (InputStream is = new FileInputStream("hello.txt")) {
byte[] buf = new byte[1024];
int len;
while (true) {
len = is.read(buf);
if (len == -1) { // 全部读完
break;
}
for (int i = 0; i < len; i++) {
System.out.printf("%c", buf[i]);
}
}
}
}
}
我的理解:这两种读法结果一样,但第二种明显更快 。原因是读文件是「和慢速设备打交道」,每调一次
read()就发起一次 IO,逐个字节读等于发起了成百上千次 IO;而按块读,一次read(buf)能捞回一大截数据,把 IO 次数从「按字节」降到「按块」,性能天差地别。这个「以空间换 IO 次数」的思路,会在全篇反复出现 ------它就是后面flush、Buffered系列类背后的同一个动机。另外要特别注意:循环退出条件永远看返回值是不是-1,而不是判断len == buf.length,因为最后一次读往往读不满一整块。
关于中文的提醒:字节流「看不懂」字符
如果把 hello.txt 写成中文「你好中国」(UTF-8 编码),用上面按字节的方式读,再强行 %c 打印就会乱码。课件里给了一个「每 3 个字节用 UTF-8 解码成一个中文」的演示:
java
for (int i = 0; i < len; i += 3) {
String s = new String(buf, i, 3, "UTF-8");
System.out.printf("%s", s);
}
课件自己也点明:这只是利用了「这几个中文字恰好 UTF-8 编码后都是 3 字节、且总长不超过 1024」的特殊巧合,并不是通用解法。
我的理解(这是全节最重要的认知拐点):
InputStream的世界里只有字节,没有字符 。它根本不知道「一个汉字占几个字节」,所以拿字节流去按字符读,注定是错配。要正确读文本,你必须把「字节」交给一个懂编码的东西去翻译------要么手动new String(bytes, charset),要么干脆用字符流 /Scanner。记住一句话:字节流负责搬运,字符流负责翻译,读文本永远别让字节流直接面对字符。
二、Scanner:把字节流按字符读的正确姿势
既然用 InputStream 直接啃字符太痛苦,就回到我们熟悉的 Scanner。它能把字节流按指定字符集翻译成字符:
| 构造方法 | 说明 |
|---|---|
Scanner(InputStream is, String charset) |
用 charset 字符集对 is 进行扫描读取 |
java
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
// hello.txt 内容为 "你好中国"
try (InputStream is = new FileInputStream("hello.txt")) {
try (Scanner scanner = new Scanner(is, "UTF-8")) {
while (scanner.hasNext()) {
System.out.print(scanner.next());
}
}
}
}
}
注意这里的 new Scanner(is, "UTF-8")------它把「字节流 + 编码」组合在一起,从此你拿到的是正确的中文字符串,而不是一堆需要你手动拼字节的数字。 这就是读文本文件时最省心的方式之一。
三、OutputStream:字节输出的总抽象
与输入对称,OutputStream 是「字节输出流」的抽象基类:
| 方法 | 说明 |
|---|---|
void write(int b) |
写入一个字节的数据 |
void write(byte[] b) |
把数组 b 中的数据全部写入 |
int write(byte[] b, int off, int len) |
把 b 中从 off 开始的 len 个字节写入 |
void close() |
关闭字节流 |
void flush() |
刷新缓冲区,把数据真正落到设备(见下,极其重要) |
同样,OutputStream 是抽象类,写文件用其实现类 FileOutputStream。
勘误与订正:课件把
write(int b)的说明写成「写入要给字节的数据」,正确表述是「写入一个字节的数据」。
flush 为什么如此重要(缓冲区的代价)
课件在 flush 的说明里写得很到位:因为 I/O 很慢 ,所以多数输出流为了减少操作设备的次数,会先把数据暂时写到内存里的一块缓冲区 ,等缓冲区满了或满足特定条件时才真正写设备。副作用就是:你写的数据可能有一部分还留在缓冲区里没落地 ,所以要在合适的位置(尤其是最后)调用 flush,把数据刷进设备。
我的理解:
flush是「缓冲区机制」的孪生代价。InputStream用缓冲是为了少读几次 ,OutputStream用缓冲是为了少写几次 ,两者动机相同;而flush就是输出方向上那个「别等了,现在就交出去」的开关。忘记 flush 的典型症状:程序看起来正常结束,文件却是空的或残缺的------数据还卡在缓冲区里没倒出来。养成「写完必 flush」的肌肉记忆,能救你无数次的深夜调试。
字节写出的几种典型写法(都记得 flush)
java
// 1) 逐字节写
try (OutputStream os = new FileOutputStream("output.txt")) {
os.write('H'); os.write('e'); os.write('l'); os.write('l'); os.write('o');
os.flush();
}
// 2) 写整个字节数组
try (OutputStream os = new FileOutputStream("output.txt")) {
byte[] b = new byte[]{(byte)'G', (byte)'o', (byte)'o', (byte)'d'};
os.write(b);
os.flush();
}
// 3) 写数组的一部分(从 off 起写 len 个)
try (OutputStream os = new FileOutputStream("output.txt")) {
byte[] b = new byte[]{(byte)'G',(byte)'o',(byte)'o',(byte)'d',(byte)'B',(byte)'a'};
os.write(b, 0, 4); // 只写前 4 个字节,即 "Good"
os.flush();
}
// 4) 字符串转字节后写(英文,默认编码即可)
try (OutputStream os = new FileOutputStream("output.txt")) {
byte[] b = "Nothing".getBytes();
os.write(b);
os.flush();
}
// 5) 中文必须显式指定编码!
try (OutputStream os = new FileOutputStream("output.txt")) {
byte[] b = "你好中国".getBytes("utf-8"); // 关键:按 utf-8 编码
os.write(b);
os.flush();
}
第 5 段是重点:写中文一定要显式 getBytes("utf-8") 。字节流本身不懂编码,你不指定编码,就可能写出与读时不一致的乱码。再次呼应那条主线:字节只负责搬运,编码才负责翻译。
OutputStreamWriter + PrintWriter:找回你熟悉的 print/println/printf
用字节流写文本还是太笨拙。课件把路线再往上抬了一层:先用 OutputStreamWriter 把字节流「包装」成字符流(并绑定编码),再用 PrintWriter 提供我们最熟悉的 print / println / printf:
java
OutputStream os = ...;
OutputStreamWriter osWriter = new OutputStreamWriter(os, "utf-8"); // 告诉它用什么编码
PrintWriter writer = new PrintWriter(osWriter);
writer.print("Hello");
writer.println("你好");
writer.printf("%d: %s\n", 1, "没什么");
writer.flush(); // 始终别忘 flush
完整可运行示例:
java
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException {
try (OutputStream os = new FileOutputStream("output.txt")) {
try (OutputStreamWriter osWriter = new OutputStreamWriter(os, "UTF-8")) {
try (PrintWriter writer = new PrintWriter(osWriter)) {
writer.println("我是第一行");
writer.print("我的第二行\r\n");
writer.printf("%d: 我的第三行\r\n", 1 + 1);
writer.flush();
}
}
}
}
}
我的理解:这里藏着一个 Java IO 最经典的设计模式------装饰器 / 包装流 。你看这个套娃:
FileOutputStream(管字节、连文件)→OutputStreamWriter(加编码、转字符)→PrintWriter(加println/printf这些便利方法)。每一层只做一件小事,层层叠加就得到强大能力。 这就是为什么 Java 的流类看起来又多又绕------它们不是功能重复,而是「各管一段、自由组合」。读懂「包装」这层关系,你就再也不怕 Java IO 那一大把类名了:看到谁包谁,就是在问「这个流在字节流的基础上,多加了编码、缓冲,还是便利方法」。
四、读与写的标准模板(务必形成肌肉记忆)
课件最后给出了四段「代码参考」模板,我把它们提炼成你以后写 IO 直接照抄的骨架。它们分别对应:按字节读、按字节写、按字符读、按字符写。 请特别注意------字节方向靠 buf,字符方向靠编码包装;写方向永远以 flush 收尾。
java
// 按字节读
try (InputStream is = ...) {
byte[] buf = new byte[1024];
while (true) {
int n = is.read(buf);
if (n == -1) break;
// buf 的 [0, n) 表示本次读到的数据,按业务处理
}
}
// 按字节写
try (OutputStream os = ...) {
byte[] buf = new byte[1024];
while (/* 还有未完成的业务数据 */) {
int n = ...; // 业务数据填入 buf,长度为 n
os.write(buf, 0, n);
}
os.flush(); // 刷新,务必保留
}
// 按字符读(最省心的文本读法)
try (InputStream is = ...) {
try (Scanner scanner = new Scanner(is, "UTF-8")) {
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
// 根据 line 做业务处理
}
}
}
// 按字符写(最省心的文本写法)
try (OutputStream os = ...) {
try (OutputStreamWriter osWriter = new OutputStreamWriter(os, "UTF-8")) {
try (PrintWriter writer = new PrintWriter(osWriter)) {
while (/* 还有未完成的业务数据 */) {
writer.println(...);
}
writer.flush(); // 刷新,务必保留
}
}
}
第四部分(分·实战):三个把知识串起来的小程序
零散的 API 背下来不算会,能组合成能跑的工具才算。课件给了三个练习,恰好把前面的知识全用上,我逐个点出它的「设计灵魂」。
实战一:扫描目录,找出名字含关键字的文件并可删除
需求:扫描一个根目录,递归找出名称中包含指定字符的所有普通文件(不含目录),并逐个询问是否删除。
设计灵魂:因为文件系统是树形结构,所以遍历用「深度优先 + 递归」 ------这正是第一部分「目录即管理文件、文件系统即树」这条认知的直接落地。File 对象的递归遍历,本质上就是数据结构里树的 DFS。
java
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入要扫描的根目录(绝对路径 OR 相对路径): ");
String rootDirPath = scanner.next();
File rootDir = new File(rootDirPath);
if (!rootDir.isDirectory()) {
System.out.println("您输入的根目录不存在或者不是目录,退出");
return;
}
System.out.print("请输入要找出的文件名中的字符: ");
String token = scanner.next();
List<File> result = new ArrayList<>();
scanDir(rootDir, token, result); // 树形结构 → 递归(深度优先)遍历
System.out.println("共找到符合条件的文件 " + result.size() + " 个:");
for (File file : result) {
System.out.println(file.getCanonicalPath() + " 是否删除该文件?y/n");
String in = scanner.next();
if (in.toLowerCase().equals("y")) {
file.delete();
}
}
}
private static void scanDir(File rootDir, String token, List<File> result) {
File[] files = rootDir.listFiles();
if (files == null || files.length == 0) {
return; // 空目录直接返回(递归出口)
}
for (File file : files) {
if (file.isDirectory()) {
scanDir(file, token, result); // 是目录 → 继续往下钻
} else {
if (file.getName().contains(token)) { // 是文件 → 判断名字
result.add(file.getAbsoluteFile());
}
}
}
}
}
注意它怎么把三件事缝在一起:isDirectory() 分流目录与文件、递归下钻、getName().contains() 过滤、delete() 执行------全是你已经会的方法,组合起来就是一个真正有用的工具。
实战二:复制一个普通文件
需求:把一个源文件复制到目标路径,途中做足校验。
设计灵魂:这是「读流 + 写流 + 缓冲区」的合体 ------用 FileInputStream 读、FileOutputStream 写,中间用一个 byte[] buf 一块块搬运。同时它示范了工程上该有的健壮性:源文件不存在 / 不是普通文件要拦、目标已存在要问是否覆盖。
java
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入要复制的文件(绝对路径 OR 相对路径): ");
File sourceFile = new File(scanner.next());
if (!sourceFile.exists()) {
System.out.println("文件不存在,请确认路径是否正确");
return;
}
if (!sourceFile.isFile()) {
System.out.println("源不是普通文件,请确认路径是否正确");
return;
}
System.out.print("请输入复制到的目标路径(绝对路径 OR 相对路径): ");
File destFile = new File(scanner.next());
if (destFile.exists()) {
if (destFile.isDirectory()) {
System.out.println("目标路径已存在且是目录,请确认路径是否正确");
return;
}
if (destFile.isFile()) {
System.out.println("目标文件已存在,是否覆盖?y/n");
if (!scanner.next().toLowerCase().equals("y")) {
System.out.println("停止复制");
return;
}
}
}
try (InputStream is = new FileInputStream(sourceFile)) {
try (OutputStream os = new FileOutputStream(destFile)) {
byte[] buf = new byte[1024];
int len;
while (true) {
len = is.read(buf);
if (len == -1) break;
os.write(buf, 0, len); // 注意只写实际读到的 len 个字节
}
os.flush();
}
}
System.out.println("复制已完成");
}
}
我的理解:这段是「按字节读」模板和「按字节写」模板拼起来的最典型案例。两个模板之间的胶水,就是那一块
buf。它再一次说明:掌握读、写两个模板,复制这种「读出来立刻写回去」的操作就是水到渠成。 另外os.write(buf, 0, len)用的是len而不是buf.length,正是呼应「最后一块读不满」这个坑。
实战三:扫描目录,找出内容含关键字的文件
需求:不仅看文件名,还要读文件内容,找出内容里出现指定字符的文件。
设计灵魂:在递归遍历的基础上,对每个普通文件用字符流(Scanner + UTF-8)读全文 再判断是否包含关键字。课件也诚实提醒:当前方案把整个文件读进内存、且对每个文件都全文扫描,性能较差,不要在过于复杂的目录或超大文件上实验。
java
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入要扫描的根目录(绝对路径 OR 相对路径): ");
File rootDir = new File(scanner.next());
if (!rootDir.isDirectory()) {
System.out.println("您输入的根目录不存在或者不是目录,退出");
return;
}
System.out.print("请输入要找出的文件内容中的字符: ");
String token = scanner.next();
List<File> result = new ArrayList<>();
scanDirWithContent(rootDir, token, result);
System.out.println("共找到符合条件的文件 " + result.size() + " 个:");
for (File file : result) {
System.out.println(file.getCanonicalPath());
}
}
private static void scanDirWithContent(File rootDir, String token, List<File> result)
throws IOException {
File[] files = rootDir.listFiles();
if (files == null || files.length == 0) return;
for (File file : files) {
if (file.isDirectory()) {
scanDirWithContent(file, token, result);
} else {
if (isContentContains(file, token)) {
result.add(file.getAbsoluteFile());
}
}
}
}
// 统一按 UTF-8 文本处理
private static boolean isContentContains(File file, String token) throws IOException {
StringBuilder sb = new StringBuilder();
try (InputStream is = new FileInputStream(file)) {
try (Scanner scanner = new Scanner(is, "UTF-8")) {
while (scanner.hasNextLine()) {
sb.append(scanner.nextLine());
sb.append("\r\n");
}
}
}
return sb.indexOf(token) != -1;
}
}
我的理解:这个练习的价值在于把「读」用到了「判断」上------读不是为了搬运,而是为了内容检索。它也暴露了朴素方案的天花板(全文入内存、全量扫描),这恰好是你未来去理解「为什么要缓冲流、为什么要按行流式处理、为什么要索引」的动机起点。知道朴素做法哪里笨,比直接背高级做法更能建立直觉。
第五部分(总):把整条线收回来,形成一张地图
回头看,这篇文章其实只做了一件事:把「文件操作」拆成认识 → 操作外壳 → 读写内容 → 实战串练四步,而这四步背后是一条清晰的分界线------
- 文件的外壳(元信息、路径、增删改名、目录) 用
File类,它是「一份描述」,不代表真实存在;遍历它用递归,因为文件系统本就是一棵树。 - 文件的内核(内容读写) 用数据流:输入用
InputStream/FileInputStream,输出用OutputStream/FileOutputStream;要正确读文本就交给Scanner,要方便地写文本就用OutputStreamWriter + PrintWriter。
而贯穿始终、值得你刻进脑子里的,是三条「为什么」:
- 为什么要缓冲区、为什么要
flush? 因为设备慢 。读侧用缓冲少发起 IO,写侧用缓冲少发起 IO,flush则是「别等了、立刻落盘」的补偿开关。忘flush导致文件残缺,是这个慢世界留下的最经典的坑。 - 为什么要区分字节流和字符流、为什么处处谈编码? 因为字节流只搬运、不翻译 。文本是「编码之后的字符」,读文本若不让字符流 /
Scanner出场,中文必然乱码。所以「英文可图省事、中文必须UTF-8」不是玄学,是这条主线的直接推论。 - 为什么 Java 的流类又多又绕、还要层层包装? 因为用的是装饰器模式 ------
FileOutputStream → OutputStreamWriter → PrintWriter各管一段、自由叠加。看穿「谁包谁」,那一大把类名瞬间从「背诵负担」变成「能力积木」。
如果只让我留给你一句可迁移的体会,那就是:IO 的一切复杂性,都是在为「设备慢」和「编码/字节」这两件事做补偿。 想明白这一点,你就不再需要死记每一个类,而是能推导出「这个场景该用什么、为什么要这么写」。文件操作如此,往后你遇到网络 IO、缓冲流、对象序列化,也是同一种思想的延伸。
把认知建立在前、把编码落在中间、把实战收在结尾------这正是我想交给你的,不只是「怎么用 Java 读写一个文件」,而是「面对任何数据流,你都知道自己在跟什么打交道」。
附:核心速查表
| 我想做什么 | 用什么 | 关键提醒 |
|---|---|---|
| 判断存在 / 类型 / 权限 | exists() / isFile() / isDirectory() / canRead() |
File 对象不代表文件真实存在 |
| 取路径(递进到「真相」) | getPath() → getAbsolutePath() → getCanonicalPath() |
比较是否同一文件用 canonical |
| 创建空文件 / 删除 | createNewFile() / delete() |
createNewFile 对已存在文件返回 false |
| 退出时清理临时文件 | deleteOnExit() |
是「登记遗嘱」,不是立即删 |
| 建多级目录 | mkdirs() |
mkdir 不补中间目录会失败 |
| 改名 / 移动 | renameTo(File dest) |
务必检查返回值 |
| 遍历目录 | listFiles() + 递归 DFS |
文件系统是树,天然递归 |
| 读文件内容(二进制) | FileInputStream + byte[] buf |
退出条件看 read 返回 -1 |
| 读文件内容(文本) | new Scanner(is, "UTF-8") |
让字符流负责翻译 |
| 写文件内容(二进制) | FileOutputStream |
写完必 flush() |
| 写文件内容(文本) | OutputStreamWriter("UTF-8") + PrintWriter |
装饰器层层包装,写完必 flush() |