java ee--文件操作和IO

从「万物皆文件」到数据流:

引言:为什么每个 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。

而贯穿始终、值得你刻进脑子里的,是三条「为什么」:

  1. 为什么要缓冲区、为什么要 flush? 因为设备慢 。读侧用缓冲少发起 IO,写侧用缓冲少发起 IO,flush 则是「别等了、立刻落盘」的补偿开关。忘 flush 导致文件残缺,是这个慢世界留下的最经典的坑。
  2. 为什么要区分字节流和字符流、为什么处处谈编码? 因为字节流只搬运、不翻译 。文本是「编码之后的字符」,读文本若不让字符流 / Scanner 出场,中文必然乱码。所以「英文可图省事、中文必须 UTF-8」不是玄学,是这条主线的直接推论。
  3. 为什么 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()

相关推荐
简 洁 冬冬15 分钟前
分页「向上取整」公式 `(total + size - 1) / size` 的完整推导
java·分页
装不满的克莱因瓶2 小时前
【从零搭建】AI大模型之ReactAgent智能体对接MCP实战
java·人工智能·ai·springai·mcp·springaialibaba
SimonKing3 小时前
AI Assistant被"隐藏"了?别慌,IDEA 2026.3 这波是换了个脑子
java·后端·程序员
Resean02233 小时前
SpringMVC 6+源码分析(九)异常处理
java·spring·springmvc
geats人山人海3 小时前
现代c++4.1
java·开发语言·c++
下一站春风里4 小时前
Spring IoC 控制反转 完整技术笔记
java·spring boot·笔记·spring
挖掘狂人4 小时前
用户连点两次「确认支付」,你的后端凭什么只扣一次钱?
java·后端·面试
codigger4 小时前
用户连点两次「确认支付」,你的后端凭什么只扣一次钱?
java·程序员·支付·java后端
Resean02234 小时前
SpringMVC 6+源码分析(十)数据绑定与类型转换
java·spring·springmvc