JavaEE 初阶 - 文件操作和IO

1、认识文件

1.1 为什么需要文件

1.程序中的数据存储在哪里

我们可以使用变量保存数据:

java 复制代码
int a = 10;
String name = "张三";

也可以使用数组保存多个数据:

java 复制代码
int[] arr = {10, 20, 30, 40};

还可以使用对象保存一组相关的数据。

这些数据通常在程序运行过程中存储在内存中。内存的读写速度较快,但是程序结束后,程序运行时使用的内存数据通常就会被释放。

例如:

java 复制代码
public class Test {
    public static void main(String[] args) {
        int score = 90;

        System.out.println(score);
    }
}

程序运行时,变量 score 保存着成绩 90。当程序结束后,这个变量就不能再通过本次运行的程序访问了。

2.为什么需要将数据保存到硬盘

假设我们正在开发一个学生成绩管理系统,需要保存学生的姓名和成绩。

如果只使用变量保存数据:

java 复制代码
public class Test {
    public static void main(String[] args) {
        String name = "张三";
        int score = 90;

        System.out.println(name);
        System.out.println(score);
    }
}

那么每次启动程序,都需要重新设置这些数据。

如果希望数据在程序结束后仍然能够保留,就需要将数据保存到硬盘等持久化存储设备中。

可以将学生信息保存到文件中,下次程序启动时,再从文件中读取这些数据。

因此,将数据保存到文件中,是实现数据持久化的一种常见方式。

3.文件的作用

文件在软件开发中具有非常重要的作用。

例如:

  • 文本编辑器使用文件保存文档。
  • 图片查看器通过文件读取图片。
  • 聊天软件可以将聊天记录保存到文件。
  • 游戏程序可以将玩家进度保存到文件。
  • Java 程序可以通过文件读取配置、记录日志、保存处理结果。

文件能够帮助程序将数据从一次运行延续到下一次运行。

1.2 什么是文件

1.文件的基本概念

文件是操作系统管理和组织数据的一种常见形式。

我们平时使用的文档、图片、视频、音频、程序代码等,都可以以文件的形式保存在存储设备中。

一个文件通常具有以下信息:

  • 文件名称
  • 文件路径
  • 文件大小
  • 文件类型
  • 文件内容
  • 文件修改时间

例如:

text 复制代码
test.txt
Student.java
photo.jpg
music.mp3
config.json

这些都是常见的文件名称。

我们可以通过文件路径定位文件,然后根据实际需求对文件进行读取、写入、创建、删除等操作。

2.文件的分类

从数据的组织和处理方式来看,文件通常可以分为文本文件和二进制文件。

(1)文本文件

文本文件主要保存按照某种字符编码组织的文本数据,可以使用文本编辑器查看其中的内容。

例如,test.txt 文件中保存着内容:Hello Java,打开文件后,我们可以直接看到这些文字。

常见的文本文件包括:

文件类型 说明
.txt 普通文本文件
.java Java 源代码文件
.html HTML 文件
.json JSON 数据文件
.xml XML 数据文件

(2)二进制文件

二进制文件通常按照特定的数据格式保存内容,不能保证使用普通文本编辑器就能正确阅读。

例如:

  • 图片文件
  • 音频文件
  • 视频文件
  • 压缩文件
  • 某些程序和数据文件

需要注意,文本文件和二进制文件并不是说计算机底层采用了两种完全不同的存储原理。计算机最终都是以二进制形式保存数据的,二者的区别主要在于数据的组织方式以及应该如何解释这些数据。

3.文件路径的概念

知道文件名称还不够,因为不同目录中可能存在同名文件。

例如:

text 复制代码
D:/Java/test.txt
D:/Java/data/test.txt

这两个文件都叫 test.txt,但是它们所在的位置不同。

为了准确找到文件,我们需要使用文件路径。

文件路径就是用来描述文件在文件系统中位置的信息。

在 Java 中,文件路径通常有绝对路径和相对路径两种表示方式。

4.绝对路径和相对路径

(1)绝对路径

绝对路径是从文件系统的根位置出发,完整描述文件位置的路径。

例如,在 Windows 系统中:

text 复制代码
C:\Users\Administrator\Desktop\test.txt

绝对路径能够明确描述文件的位置,但是具体路径会受到操作系统、磁盘分区和目录结构等因素影响。

(2)相对路径

相对路径是相对于某个起点来描述文件位置的路径。

在 Java 程序中,使用相对路径时,通常需要结合程序的当前工作目录来确定实际位置。

例如:

text 复制代码
test.txt
data/test.txt

其中:

  • test.txt 表示当前工作目录下的文件。
  • data/test.txt 表示当前工作目录下 data 目录中的文件。

可以通过下面的代码查看 Java 程序的当前工作目录:

java 复制代码
public class Test {
    public static void main(String[] args) {
        String path = System.getProperty("user.dir");

        System.out.println(path);
    }
}

需要注意,当前工作目录不一定就是 Java 源代码所在的目录,也不一定就是项目根目录,它取决于程序的启动方式和运行环境。

因此,当程序无法找到文件时,可以先检查当前工作目录以及相对路径是否正确。

1.3 Java 中的文件操作

1.Java 文件操作的基本思路

在 Java 中,文件操作通常包括两个方面:

  • 对文件本身进行操作,例如判断文件是否存在、获取文件属性、创建文件和删除文件。
  • 对文件内容进行操作,例如读取文件中的数据、向文件写入数据。

例如,我们读取 test.txt 文件,步骤为:

text 复制代码
1.确定文件路径
2.找到对应的文件
3.创建输入流
4.读取文件内容
5.处理读取到的数据
6.关闭流,释放资源

如果需要写入文件,则会将输入流替换为输出流。

2.File 类的作用

Java 提供了 java.io.File 类,用来表示文件或目录的路径,并提供一系列文件系统操作方法。

例如:

java 复制代码
import java.io.File;

public class Test {
    public static void main(String[] args) {
        File file = new File("test.txt");

        System.out.println(file.exists());
        System.out.println(file.getName());
        System.out.println(file.getAbsolutePath());
    }
}

这里使用 new File("test.txt") 创建了一个 File 对象,然后通过它判断路径是否存在、获取名称以及查看绝对路径。

3.File 类和文件内容的关系

刚开始很容易将 File 类与文件读写混淆。

实际上,File 类主要负责表示路径和操作文件系统中的文件或目录,并不直接提供读取、写入文件内容的功能。

例如:

java 复制代码
File file = new File("test.txt");

这行代码只是创建了一个表示 test.txt 路径的对象,并不会自动在硬盘上创建文件。

如果需要创建真实文件,可以调用 createNewFile();如果需要读取或写入文件内容,则通常需要使用 IO 流。

2. File 类

2.1 File 类的基本使用

1.创建 File 对象

在 Java 中,可以通过 File 类的构造方法创建文件对象。

java 复制代码
import java.io.File;

public class Test {
    public static void main(String[] args) {
        File file = new File("test.txt");

        System.out.println(file);//这里打印出来的是 test.txt ,是因为File类重写了toString()方法
    }
}

这里通过new File("test.txt") 创建了一个 File 对象。

需要注意,创建 File 对象不等于在磁盘上创建文件。它只是描述了一个路径。

如果需要在磁盘上创建真实文件,需要调用相应的方法,例如createNewFile()。

2.使用不同方式表示文件路径

File 类提供了多个构造方法,方便我们根据不同情况描述文件路径。

构造方法 作用
File(String pathname) 根据路径创建 File 对象
File(String parent, String child) 根据父路径和子路径创建 File 对象
File(File parent, String child) 根据父目录对象和子路径创建 File 对象

例如:

java 复制代码
import java.io.File;

public class Test {
    public static void main(String[] args) {
        File file1 = new File("test.txt");

        File file2 = new File("data", "test.txt");

        File parent = new File("data");
        File file3 = new File(parent, "test.txt");

        System.out.println(file1);
        System.out.println(file2);
        System.out.println(file3);
    }
}

这几种写法都可以用来描述路径。

如果父目录已经由一个 File 对象表示,使用File(File parent, String child)通常会更加方便。

3.文件对象与真实文件的关系

我们可以通过下面的代码进一步理解 File 对象和真实文件之间的关系:

java 复制代码
import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        File file = new File("test.txt");

        System.out.println("创建对象后:" + file.exists());

        boolean result = file.createNewFile();

        System.out.println("创建文件结果:" + result);
        System.out.println("文件是否存在:" + file.exists());
    }
}

假设当前目录中原本不存在 test.txt,运行程序后,createNewFile() 会尝试创建一个空文件。

如果文件原本就存在,createNewFile() 不会覆盖文件内容,而是返回 false。

因此,我们可以把 File 对象理解为文件路径的一个程序表示,而不是文件内容本身。

2.2 File 类的常见方法

1.获取文件信息

File 类提供了一些方法,用于获取文件或目录的基本信息。

方法 作用
getName() 获取文件或目录的名称
getPath() 获取路径的字符串表示
getAbsolutePath() 获取绝对路径
getParent() 获取父路径;没有父路径时可能返回 null
length() 获取普通文件的字节长度
lastModified() 获取最后修改时间,返回毫秒时间戳

例如:

java 复制代码
import java.io.File;

public class Test {
    public static void main(String[] args) {
        File file = new File("test.txt");

        System.out.println("名称:" + file.getName());
        System.out.println("路径:" + file.getPath());
        System.out.println("绝对路径:" + file.getAbsolutePath());
        System.out.println("父路径:" + file.getParent());
        System.out.println("文件大小:" + file.length());
        System.out.println("修改时间:" + file.lastModified());
    }
}

这里的 length() 返回的是字节数,而不是字符数。

例如,一个 UTF-8 编码的文本文件中,如果包含中文字符,其字节数通常与字符数量不同。

另外,lastModified() 返回的是时间戳。如果需要将其转换为便于阅读的日期时间,可以进一步使用 Java 的日期时间 API。

2.判断文件是否存在

在执行文件操作之前,经常需要判断目标路径是否存在。

常用方法如下:

方法 作用
exists() 判断路径是否存在
isFile() 判断是否为普通文件
isDirectory() 判断是否为目录
canRead() 判断当前程序是否可以读取
canWrite() 判断当前程序是否可以写入

例如:

java 复制代码
import java.io.File;

public class Test {
    public static void main(String[] args) {
        File file = new File("test.txt");

        if (file.exists()) {
            System.out.println("路径存在");

            if (file.isFile()) {
                System.out.println("这是一个文件");
            }

            if (file.isDirectory()) {
                System.out.println("这是一个目录");
            }
        } else {
            System.out.println("路径不存在");
        }
    }
}

需要注意,exists() 只能告诉我们检查时该路径是否存在,并不能保证之后的文件操作一定成功。文件可能被其他程序删除,或者操作时遇到权限等问题,因此实际操作仍然需要考虑异常处理。

3.创建文件

如果希望在指定位置创建一个新文件,可以使用 createNewFile()。

java 复制代码
import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        File file = new File("test.txt");

        if (file.createNewFile()) {
            System.out.println("文件创建成功");
        } else {
            System.out.println("文件已经存在");
        }
    }
}

需要注意:

  • 如果文件不存在,并且创建成功,方法返回 true。
  • 如果文件已经存在,方法返回 false。
  • 如果父目录不存在,或者发生权限、IO 等问题,可能抛出异常。

createNewFile() 只能创建文件,不能自动创建缺失的父目录。

4.创建目录

创建目录时,可以使用 mkdir() 和 mkdirs()。

java 复制代码
import java.io.File;

public class Test {
    public static void main(String[] args) {
        File dir1 = new File("data");
        File dir2 = new File("data/test/log");

        System.out.println(dir1.mkdir());
        System.out.println(dir2.mkdirs());
    }
}

二者的区别如下:

方法 作用
mkdir() 创建单级目录,父目录必须已经存在
mkdirs() 创建多级目录,必要时会创建缺失的父目录

例如,当前目录下没有 data 文件夹时,mkdirs() 可以尝试一次性创建 data/test/log 这几级目录。

5.删除文件或目录

可以使用 delete() 删除文件或空目录。

java 复制代码
import java.io.File;

public class Test {
    public static void main(String[] args) {
        File file = new File("test.txt");

        if (file.delete()) {
            System.out.println("删除成功");
        } else {
            System.out.println("删除失败,或目标不存在");
        }
    }
}

需要注意,delete() 不会自动递归删除非空目录。删除重要文件之前,应当确认目标路径是否正确,避免误删数据。

6.遍历目录中的文件

File 类提供了 list() 和 listFiles() 等方法,可以获取目录中的直接子项。

例如:

java 复制代码
import java.io.File;

public class Test {
    public static void main(String[] args) {
        File dir = new File(".");

        File[] files = dir.listFiles();

        if (files == null) {
            System.out.println("无法读取目录内容");
            return;
        }

        for (File file : files) {
            System.out.println(file.getName());
        }
    }
}

这里使用 "." 表示当前工作目录。

listFiles() 返回的是该目录下的直接子文件和子目录,并不会自动深入遍历每一个子目录。如果需要遍历完整的目录结构,就需要使用递归等方式。

2.3 File 类的综合使用

1.获取指定目录下的所有文件

例如,我们希望获取 data 目录中的所有直接子项:

java 复制代码
import java.io.File;

public class Test {
    public static void main(String[] args) {
        File dir = new File("data");

        File[] files = dir.listFiles();

        if (files == null) {
            System.out.println("目录不存在,或无法读取目录内容");
            return;
        }

        for (File file : files) {
            System.out.println(file.getAbsolutePath());
        }
    }
}

这里遍历的是 data 目录的直接子项。如果其中还包含其他目录,则不会自动显示这些子目录内部的内容。

2.递归遍历目录

如果希望遍历目录中的所有层级,可以使用递归。

递归的基本思路是:先处理当前目录中的每个子项,如果子项是文件,就输出文件信息;如果子项是目录,就继续遍历该目录。

java 复制代码
import java.io.File;

public class Test {
    public static void main(String[] args) {
        File dir = new File("data");

        printFiles(dir);
    }

    public static void printFiles(File dir) {
        File[] files = dir.listFiles();

        if (files == null) {
            return;
        }

        for (File file : files) {
            if (file.isFile()) {
                System.out.println(file.getAbsolutePath());
            } else if (file.isDirectory()) {
                printFiles(file);
            }
        }
    }
}

对于普通目录结构,这种递归写法比较容易理解。但在处理特别深的目录、访问受限的目录或符号链接时,还需要考虑递归深度和遍历安全问题。

3.文件操作中的常见问题

使用 File 类时,需要注意以下几点:

  • 创建 File 对象并不会自动创建真实文件。
  • 相对路径取决于程序的当前工作目录。
  • listFiles() 可能返回 null,不能直接假设它一定返回数组。
  • delete() 不能直接删除包含内容的非空目录。
  • 文件操作可能受到权限、路径和文件系统状态的影响。

3. 文件内容的读写

3.1 为什么需要读写文件

1.文件路径和文件内容的区别

前面介绍了 File 类,它主要用于描述文件路径和操作文件系统中的文件或目录。

但在实际中,我们往往不仅需要知道文件在哪里,还需要读取或修改文件中的数据。

例如,test.txt 文件中保存了内容:Hello Java 。

如果我们只创建一个 File 对象:

java 复制代码
File file = new File("test.txt");

程序并不会自动读取文件中的文字。

如果需要读取文件内容,就需要使用输入流;如果需要向文件写入内容,就需要使用输出流。

因此,文件路径解决的是"操作哪个文件"的问题,IO 流解决的是"如何读取或写入文件内容"的问题。

2.如何读取文件中的数据

读取文件时,需要建立从文件到程序的数据传输过程。

例如,我们可以使用 FileInputStream 读取文件中的字节,也可以使用 FileReader 读取文本字符。

如果读取过程中发生异常,也需要正确处理,并确保相关资源能够关闭。

3.如何向文件中写入数据

写入文件时,数据的流动方向与读取相反。

程序先创建输出流,然后将需要保存的数据写入文件。

基本流程如下:

text 复制代码
1.准备需要写入的数据

2.创建输出流

3.调用 write() 写入数据

4.刷新缓冲数据(必要时)

5.关闭输出流

需要注意,输出流的默认写入方式可能会覆盖原有文件内容。创建输出流时,应当根据需要选择覆盖或追加模式。

3.2 文件读写的基本认识

1.什么是输入和输出

IO 中的输入和输出,都是相对于程序而言的。

  • 输入:数据从外部进入程序。
  • 输出:数据从程序传递到外部。

例如:

text 复制代码
从文件读取数据:文件 -> 输入流 -> Java 程序


向文件写入数据:Java 程序 -> 输出流 -> 文件

除了文件之外,流还可以连接内存、网络连接以及其他数据来源或目标。IO 流通过统一的读取和写入接口,简化了数据传输的过程。

2.什么是输入流和输出流

输入流负责读取数据,输出流负责写入数据。

Java 中最基础的字节流抽象类是 InputStream 和 OutputStream,最基础的字符流抽象类是 Reader 和 Writer。

它们的关系可以简单表示为:

text 复制代码
IO 流中包含:字节流、字符流

字节流中包含:
		InputStream -> 读字节
		OutputStream -> 写字节

字符流包含:
		Reader -> 读字符
		Writer -> 写字符

这些抽象类定义了基本的读取和写入能力,具体的文件流类则实现相应的功能。

3.字节流和字符流的区别

字节流以字节为基本处理单位,适合处理原始二进制数据;字符流以字符为基本处理单位,适合处理文本内容。

例如:

  • 复制图片、音频、视频,通常使用字节流。
  • 读取文本文件中的文字,通常使用字符流。
  • 需要指定文本编码时,可以使用转换流将字节流转换为字符流。

需要注意,字符流并不是简单地把每个字节直接转换成一个字符,而是需要依据字符编码进行解码和编码。

4.文件读写的基本流程

文件读写通常需要完成以下步骤:

text 复制代码
1. 确定要操作的文件。
2. 创建输入流或输出流。
3. 读取或写入数据。
4. 根据需要处理异常。
5. 关闭流,释放资源。

4. Java 的 IO 流

4.1 什么是 IO

1.IO 的基本概念

IO 是 Input 和 Output 的缩写,分别表示输入和输出。

在 Java 中,IO 主要用于实现程序与外部数据源之间的数据传输。例如,读取文件、写入文件、从网络连接接收数据,都属于 IO 操作。

Java 的传统 IO 主要位于 java.io 包中,其中包含输入流、输出流、文件流、字符流、缓冲流等一系列类。

2.Java 中的 IO 操作

我们可以把 IO 操作理解为数据从一个地方传输到另一个地方。

例如,读取文本文件:

text 复制代码
test.txt -> 输入流 -> Java 程序 -> 处理文本内容

向文本文件写入内容:

text 复制代码
Java 程序 -> 输出流 -> test.txt

通过 IO 流,程序不需要直接处理文件系统底层的具体操作,而是通过统一的接口完成数据读取和写入。

3.IO 流的分类

Java 中的 IO 流可以从不同角度进行分类。

按照数据处理单位分类:

  • 字节流:以字节为基本单位。
  • 字符流:以字符为基本单位。

按照数据流动方向分类:

  • 输入流:读取数据。
  • 输出流:写入数据。

两种分类方式结合起来,就可以得到以下四种基本类型:

类型 主要抽象类 作用
字节输入流 InputStream 读取字节数据
字节输出流 OutputStream 写入字节数据
字符输入流 Reader 读取字符数据
字符输出流 Writer 写入字符数据

4.2 字节流

1.什么是字节流

字节流以字节为基本单位进行数据传输。

在 Java 中,一个字节包含 8 个二进制位。字节流适合处理各种原始数据,例如图片、视频、音频、压缩包等。

需要注意,字节流也可以读取和写入文本文件,只是当我们需要处理文本中的字符时,通常使用字符流会更加方便。

Java 中的字节输入流和字节输出流分别以 InputStream 和 OutputStream 为基础。

2.InputStream 类

InputStream 是 Java 字节输入流的抽象基类。

它定义了一些常见方法:

方法 作用
read() 读取一个字节,返回 -1 表示到达文件末尾
read(byte[] b) 将读取的数据放入字节数组
read(byte[] b, int off, int len) 从指定偏移位置开始读取数据
close() 关闭输入流

例如:

java 复制代码
int data = input.read();

如果读取成功,返回的是字节值;如果已经到达输入流末尾,则返回 -1。

为什么返回类型是 int,而不是 byte?

因为 byte 的取值范围为 -128 到 127,read() 读到正常字节就会返回这个字节的无符号值(0-255),读到文件末尾就会返回 -1 。因此使用 int 可以避免将合法的字节数据与结束标志混淆。

3.OutputStream 类

OutputStream 是 Java 字节输出流的抽象基类。

常见方法如下:

方法 作用
write(int b) 写出一个字节
write(byte[] b) 写出字节数组
write(byte[] b, int off, int len) 写出字节数组的一部分
flush() 刷新输出流中的缓冲数据
close() 关闭输出流

例如:

java 复制代码
output.write(65);

这里写入的是一个字节,其值为 65,对应 ASCII 编码中的大写字母 A。

需要注意,write(int b) 主要写出参数的低 8 位,并不是将一个完整的 Java int 值的所有字节都写入文件。

如果希望写入字符串,可以先将字符串按照指定字符集转换成字节数组,再使用 write() 写入。

4.文件字节输入流 FileInputStream

FileInputStream 是用于从文件读取字节数据的常见类。

例如,创建 test.txt 文件,并写入:Hello Java ,然后使用 FileInputStream 读取文件:

java 复制代码
import java.io.FileInputStream;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (FileInputStream input = new FileInputStream("test.txt")) {

            int data;

            while ((data = input.read()) != -1) {
                System.out.print((char) data);
            }
        }
    }
}

运行后,程序会读取文件中的字节,并将简单的 ASCII 字节转换为字符输出。

这里需要注意:这种逐字节转换为 char 的写法只适用于相应字节确实对应简单字符的场景。对于 UTF-8 编码的中文文本,不能将每个字节单独转换为字符,否则可能产生乱码。

5.文件字节输出流 FileOutputStream

FileOutputStream 用于向文件写入字节数据。

例如:

java 复制代码
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class Test {
    public static void main(String[] args) throws IOException {
        try (FileOutputStream output = new FileOutputStream("test.txt")) {

            byte[] data = "Hello Java".getBytes(StandardCharsets.UTF_8);

            output.write(data);
        }
    }
}

程序运行后,会将字符串转换为 UTF-8 字节数组,再写入文件。

需要注意,普通的 FileOutputStream 构造方法默认会覆盖原有文件内容。如果需要追加写入,可以使用:

java 复制代码
new FileOutputStream("test.txt", true)

其中第二个参数为 true 时表示追加模式。

6.字节流的综合使用

字节流最常见的用途之一,就是复制文件。

例如,将 source.jpg 复制到 copy.jpg:

java 复制代码
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (FileInputStream input = new FileInputStream("source.jpg");
             FileOutputStream output = new FileOutputStream("copy.jpg")) {

            byte[] buffer = new byte[4096];
            int len;

            while ((len = input.read(buffer)) != -1) {
                output.write(buffer, 0, len);
            }
        }

        System.out.println("复制完成");
    }
}

这里没有一次性将整个文件加载到内存,而是每次读取一批字节,再将实际读取到的内容写入目标文件。

这种方式可以用于复制较大的文件,并且不会因为文件整体过大而直接占用同等大小的内存。

4.3 字符流

1.什么是字符流

字符流以字符为基本处理单位,主要用于文本数据的读取和写入。

在 Java 中,字符输入流的抽象基类是 Reader,字符输出流的抽象基类是 Writer。

字符流在处理文本时,会涉及字符编码和解码转换。因此,使用字符流读取文本时,需要确保实际使用的字符集与文件的编码相匹配。

2.Reader 类

Reader 是字符输入流的抽象基类。

常见方法如下:

方法 作用
read() 读取一个字符,返回 -1 表示结束
read(char[] cbuf) 将读取到的字符放入字符数组
read(char[] cbuf, int off, int len) 从指定位置开始读取字符
close() 关闭字符输入流

例如:

java 复制代码
int data = reader.read();

这里的返回值是 int,成功读取时包含一个字符的代码单元值,读取结束时返回 -1。

3.Writer 类

Writer 是字符输出流的抽象基类。

常见方法如下:

方法 作用
write(int c) 写入一个字符代码单元
write(char[] cbuf) 写入字符数组
write(String str) 写入字符串
flush() 刷新输出流
close() 关闭输出流

例如:

java 复制代码
writer.write("Hello Java");

与字节流相比,字符流能够直接处理字符串和字符数组,因此在文本读写场景中通常更加方便。

4.文件字符输入流 FileReader

FileReader 是常见的文件字符输入流。

例如:

java 复制代码
import java.io.FileReader;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (FileReader reader = new FileReader("test.txt")) {
            int data;

            while ((data = reader.read()) != -1) {
                System.out.print((char) data);
            }
        }
    }
}

这里通过 read() 逐个读取字符,并输出到控制台。

对于文本文件,这种方式比逐字节读取更适合处理普通文字。

不过,字符流同样需要正确的字符编码。如果文件使用 UTF-8 编码,而程序采用的字符集不匹配,仍然可能出现乱码。

在 Java 11 及以上版本,可以直接指定 FileReader 的字符集:

java 复制代码
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class Test {
    public static void main(String[] args) throws IOException {
        try (FileReader reader = new FileReader("test.txt", StandardCharsets.UTF_8)) {

            int data;

            while ((data = reader.read()) != -1) {
                System.out.print((char) data);
            }
        }
    }
}

如果使用 Java 8,可以通过 InputStreamReader 配合 FileInputStream 指定字符集。

5.文件字符输出流 FileWriter

FileWriter 用于将字符内容写入文件。

例如:

java 复制代码
import java.io.FileWriter;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (FileWriter writer = new FileWriter("test.txt")) {
            writer.write("Hello Java");
            writer.write("\n");
            writer.write("欢迎学习 Java");
        }
    }
}

程序运行后,文件中就会保存相应的文本内容。

如果希望追加内容,可以使用:

java 复制代码
new FileWriter("test.txt", true)

需要注意,FileWriter 的普通构造方法会使用覆盖模式,而且在不同 Java 版本中,可用的字符集构造方法有所区别。为了保证跨环境读写结果一致,建议明确指定字符集。

6.字符流的综合使用

如果需要将一个文本文件的内容复制到另一个文本文件,可以使用 FileReader 和 FileWriter。

java 复制代码
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (FileReader input = new FileReader("source.txt");
             FileWriter output = new FileWriter("copy.txt")) {

            char[] buffer = new char[1024];
            int len;

            while ((len = input.read(buffer)) != -1) {
                output.write(buffer, 0, len);
            }
        }

        System.out.println("文本复制完成");
    }
}

这里每次读取一批字符,再将读取到的字符写入目标文件。

对于明确指定编码的实际项目,可以使用 InputStreamReader 和 OutputStreamWriter,或者使用 Files.newBufferedReader() 和 Files.newBufferedWriter() 等 API。

4.4 字节流和字符流的区别

1.处理数据的基本单位不同

字节流以字节为基本单位,字符流以字符为基本单位。

字节流通常直接处理原始字节数据,而字符流会在字节与字符之间进行编码或解码转换。

2.适用场景不同

字节流适用于各种原始数据,例如图片、视频、压缩文件等。

字符流则更适合读取和写入文本内容,例如 .txt、.java、.json 等文件。

需要注意,文本文件也可以通过字节流读取,只是在需要处理文字内容时,通常字符流更方便。

3.如何选择合适的流

使用场景 推荐方式
复制图片、视频、压缩文件 字节流
读取普通文本 字符流
写入字符串 字符流
需要严格控制文本编码 转换流或指定字符集的文件 API
处理原始二进制协议数据 字节流

可以先记住:处理原始字节数据时优先考虑字节流,处理文本内容时优先考虑字符流。

4.5 关闭流与资源管理

1.为什么需要关闭流

文件流可能占用操作系统的文件句柄等资源。如果使用完毕后不及时关闭,可能导致资源不能及时释放。

例如:

java 复制代码
FileInputStream input = new FileInputStream("test.txt");

创建输入流后,如果程序一直不关闭它,就可能让文件保持打开状态,影响后续操作。

因此,流使用完毕后,应当及时关闭。

2.close() 方法的作用

close() 用于关闭流并释放相关资源。

例如:

java 复制代码
import java.io.FileInputStream;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        FileInputStream input = new FileInputStream("test.txt");

        try {
            System.out.println(input.read());
        } finally {
            input.close();
        }
    }
}

这里使用 finally,是为了让关闭操作在正常执行或发生异常时都能得到执行。

不过,这种写法还需要考虑流创建失败等情况,实际写代码的时候更推荐try-with-resources。

3.try-with-resources 的使用

从 Java 7 开始,可以使用 try-with-resources 自动关闭实现了 AutoCloseable 接口的资源。

例如:

java 复制代码
import java.io.FileInputStream;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (FileInputStream input = new FileInputStream("test.txt")) {

            System.out.println(input.read());
        }
    }
}

当 try 代码块结束时,Java 会自动关闭输入流。

这种方式可以减少手动关闭资源的代码,也能更可靠地处理异常情况。

如果同时使用多个流,也可以将它们放在同一个资源声明中:

java 复制代码
try (FileInputStream input = new FileInputStream("source.txt");
     FileOutputStream output = new FileOutputStream("copy.txt")) {

    // 文件读写操作
}

资源会在代码块结束时自动关闭。

4.资源管理中的常见问题

使用 IO 流时,需要特别注意以下几点:

  • 不要忘记关闭流,优先使用 try-with-resources。
  • 不要在关闭流之后继续使用它。
  • 输出流可能存在缓冲数据,关闭流时会执行必要的刷新操作。
  • flush() 与 close() 不同,刷新并不代表关闭流。
  • 如果使用多个包装流,通常只需要关闭最外层流,它会负责关闭其内部包装的流。

5. 文件读写的常见问题

5.1 文件内容的追加与覆盖

1.默认写入行为

在使用文件输出流时,需要特别注意文件原有内容是否会被覆盖。

例如:

java 复制代码
import java.io.FileWriter;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (FileWriter writer = new FileWriter("test.txt")) {
            writer.write("Hello Java");
        }
    }
}

如果 test.txt 原本已经存在内容,那么使用普通的 FileWriter 构造方法打开文件时,原有内容会被覆盖。

例如,原文件内容是第一次写入,运行程序后,文件内容就会变成 Hello Java 了。

2.如何追加文件内容

如果想保留原有内容,可以在创建输出流时设置为追加模式。

例如:

java 复制代码
import java.io.FileWriter;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (FileWriter writer = new FileWriter("test.txt", true)) {
            writer.write("\n追加的新内容");
        }
    }
}

这里的第二个参数为 true,表示以追加模式打开文件。

如果文件原本不存在,输出流通常会创建该文件;如果文件已经存在,新内容就会追加到原有内容之后。

3.追加模式的使用场景

追加模式经常用于以下场景:

  • 记录程序运行日志。
  • 保存用户操作记录。
  • 向文本文件持续追加数据。
  • 记录程序执行过程中的错误信息。

覆盖模式则适合重新生成文件内容的场景,例如重新生成报告、更新某些配置文件等。

写入方式 示例 行为
覆盖写入 new FileWriter("test.txt") 覆盖原有内容
追加写入 new FileWriter("test.txt", true) 保留原有内容并追加

5.2 文本文件的读写

1.按字节读取文本

文本文件本质上也是由字节组成的,因此可以使用 FileInputStream 读取。

例如:

java 复制代码
import java.io.FileInputStream;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (FileInputStream input = new FileInputStream("test.txt")) {

            int data;

            while ((data = input.read()) != -1) {
                System.out.print(data + " ");
            }
        }
    }
}

这里输出的是读取到的字节值,而不是直接输出原始文本。

如果文件采用 UTF-8 编码,中文字符可能由多个字节组成,因此不能简单地将每个字节单独转换为字符。

2.按字符读取文本

如果需要直接处理文字内容,可以使用 FileReader。

java 复制代码
import java.io.FileReader;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (FileReader reader = new FileReader("test.txt")) {
            int data;

            while ((data = reader.read()) != -1) {
                System.out.print((char) data);
            }
        }
    }
}

这种方式会将文件中的字节解码为字符,便于处理文本。

不过,使用字符流时仍然需要关注字符集。如果文件编码与读取时采用的字符集不一致,仍然可能出现乱码。

3.字符编码的基本认识

计算机底层保存的是字节,而程序需要处理字符,因此必须通过字符编码建立两者之间的转换关系。

写入文件时,通常需要将字符编码为字节;读取文件时,则需要将字节解码为字符。

如果编码和解码使用的字符集不一致,就可能出现乱码。

4.UTF-8 与乱码问题

UTF-8 是一种常见的 Unicode 编码方式,能够表示中文、英文以及其他多种语言中的字符。

在 Java 中,可以使用 StandardCharsets.UTF_8 明确指定 UTF-8 编码。

例如,将字符串转换为 UTF-8 字节数组:

java 复制代码
import java.nio.charset.StandardCharsets;

public class Test {
    public static void main(String[] args) {
        String str = "你好,Java";

        byte[] bytes = str.getBytes(StandardCharsets.UTF_8);

        String result = new String(bytes, StandardCharsets.UTF_8);

        System.out.println(result);
    }
}

这里的编码和解码都使用 UTF-8,因此可以正确还原原来的字符串。

实际读写文件时,也应尽量明确指定字符集。例如,Java 8 可以使用 InputStreamReader 和 OutputStreamWriter,而 Java 11 及以上版本还提供了支持指定字符集的 FileReader 和 FileWriter 构造方法。

处理文本文件时,明确指定字符编码,是避免乱码的重要习惯。

5.3 二进制文件的读写

1.什么是二进制文件

二进制文件通常按照特定格式保存数据,例如图片、音频、视频和压缩文件等。

这些文件中的字节不一定对应普通文本字符,必须按照对应的文件格式进行解释。

2.图片等文件的复制

复制二进制文件时,通常使用字节流。

例如:

java 复制代码
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (FileInputStream input = new FileInputStream("source.jpg");
             FileOutputStream output = new FileOutputStream("copy.jpg")) {

            byte[] buffer = new byte[4096];
            int len;

            while ((len = input.read(buffer)) != -1) {
                output.write(buffer, 0, len);
            }
        }

        System.out.println("图片复制完成");
    }
}

程序通过字节数组分批读取文件内容,再将读取到的字节写入目标文件。

这样可以保留源文件的原始字节内容,避免文本编码转换对文件数据造成影响。

3.为什么不能随意使用字符流处理二进制数据

字符流需要将字节转换为字符,或者将字符转换为字节。

但是,图片、视频等二进制文件中的数据通常并不代表普通文本。如果强行使用字符流处理这些数据,编码和解码过程就可能改变原始字节内容,最终导致复制后的文件损坏。

因此,可以记住:

  • 复制图片、视频等二进制文件,优先使用字节流。
  • 读取文本内容,通常使用字符流。
  • 不要将任意二进制数据直接当作普通文本进行编码和解码。

5.4 文件读写中的异常处理

1.常见的 IO 异常

文件操作可能受到文件状态、权限和存储设备等因素影响,因此可能发生异常。

常见情况包括:

  • 文件不存在。
  • 路径不正确。
  • 文件没有读取或写入权限。
  • 磁盘空间不足。
  • 文件读写过程中发生 IO 错误。

Java 中许多文件读写方法会声明抛出 IOException,因此需要通过 try-catch 或 throws 等方式处理异常。

2.文件不存在时怎么办

例如,读取一个不存在的文件:

java 复制代码
import java.io.FileInputStream;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        try (FileInputStream input = new FileInputStream("not-exist.txt")) {

            System.out.println(input.read());

        } catch (IOException e) {
            System.out.println("文件读取失败:" + e.getMessage());
        }
    }
}

如果文件不存在,创建输入流时就可能发生异常,程序会进入 catch 代码块。

需要注意,FileInputStream 不会因为文件不存在就自动创建一个空文件。

如果需要创建文件,应当明确调用相应的创建方法,或者使用适合该需求的文件输出 API。

3.读写权限问题

即使文件存在,也不代表程序一定能够读取或写入。

例如:

  • 文件可能受到操作系统权限限制。
  • 目标目录可能不允许创建文件。
  • 文件可能处于某种特殊的访问状态。
  • 程序可能没有足够的权限访问对应路径。

可以使用 canRead() 和 canWrite() 等方法进行初步检查,但这些检查并不能保证后续操作一定成功。因此,实际读写仍然需要处理可能发生的异常。

4.如何合理处理异常

异常处理不能只是简单地输出一条信息,还需要根据实际情况决定。

例如:

java 复制代码
try (FileWriter writer = new FileWriter("test.txt")) {
    writer.write("Hello Java");
} catch (IOException e) {
    System.out.println("文件写入失败:" + e.getMessage());
}

对于简单的示例,这样可以帮助我们理解异常处理的基本方式。

对于真实项目,还可以根据需要记录日志、向上层抛出异常、提示用户重试,或者执行其他补救措施。

6. 缓冲流

6.1 为什么需要缓冲流

1.普通文件流的读写方式

前面介绍了 FileInputStream 和 FileOutputStream 等文件流。

它们可以直接完成文件读写,但如果程序频繁进行小规模读写,可能会产生较多的调用开销。

例如,使用下面的代码逐字节复制文件:

java 复制代码
int data;

while ((data = input.read()) != -1) {
    output.write(data);
}

这段代码每次循环读取一个字节,再写入一个字节。对于较大的文件,通常更适合使用缓冲区批量处理数据。

2.缓冲机制的基本思想

缓冲机制的核心思想,是在内存中暂存一批数据,再进行批量读写。

例如,读取文件时,可以先将一批数据读入缓冲区,再从缓冲区中逐步处理。

对于输出操作,也可以先将数据写入缓冲区,待缓冲区达到一定条件或主动刷新时,再向下一层输出目标写出数据。

3.缓冲流的作用

Java 提供了四种常见的缓冲流:

类 作用
BufferedInputStream 为字节输入提供缓冲
BufferedOutputStream 为字节输出提供缓冲
BufferedReader 为字符输入提供缓冲
BufferedWriter 为字符输出提供缓冲

缓冲流通常通过包装普通流的方式使用,可以减少频繁小规模读写带来的开销。

6.2 字节缓冲流

1.BufferedInputStream

BufferedInputStream 是带缓冲功能的字节输入流。

它可以包装其他字节输入流,例如:

java 复制代码
BufferedInputStream input =new BufferedInputStream(new FileInputStream("test.txt"));

这里的 FileInputStream 负责从文件读取字节,BufferedInputStream 则提供缓冲功能。

2.BufferedOutputStream

BufferedOutputStream 是带缓冲功能的字节输出流。

例如:

java 复制代码
BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream("copy.txt"));

写入数据时,内容可以先进入缓冲区,之后再批量输出。

如果缓冲区中还有数据没有写出,在关闭流时会执行必要的刷新操作,因此仍然需要正确关闭流。

3.字节缓冲流的基本使用

下面通过缓冲字节流实现文件复制:

java 复制代码
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (BufferedInputStream input = new BufferedInputStream(new FileInputStream("source.jpg"));
             BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream("copy.jpg"))) {

            byte[] buffer = new byte[4096];
            int len;

            while ((len = input.read(buffer)) != -1) {
                output.write(buffer, 0, len);
            }
        }

        System.out.println("复制完成");
    }
}

这里通过缓冲流包装文件流,再使用字节数组批量读写文件。

需要注意,代码中的 4096 是应用程序使用的字节数组长度,并不是缓冲流内部缓冲区大小的设置。两者属于不同层次的缓冲。

6.3 字符缓冲流

1.BufferedReader

BufferedReader 是带缓冲功能的字符输入流,除了提供缓冲能力之外,还提供了方便的按行读取方法 readLine()。

例如:

java 复制代码
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader("test.txt"))) {

            String line;

            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        }
    }
}

这里的 readLine() 每次返回一行文本,到达文件末尾时返回 null。

需要注意,readLine() 返回的字符串不包含原来的行结束符。如果需要保留换行结构,应当在写入时自行添加换行符。

2.BufferedWriter

BufferedWriter 是带缓冲功能的字符输出流。

例如:

java 复制代码
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("test.txt"))) {

            writer.write("第一行");
            writer.write("第二行");
        }
    }
}

需要注意,write() 不会自动添加换行符,因此上述两段文字会直接连接起来。

如果希望每段文字单独占一行,可以使用 newLine()。

3.readLine() 方法

readLine() 用于读取一行文本,并返回不包含行结束符的字符串。

例如:

java 复制代码
String line;

while ((line = reader.readLine()) != null) {
    System.out.println(line);
}

这里通过判断返回值是否为 null,确定是否已经读取到文件末尾。

4.newLine() 方法

newLine() 用于写入当前平台对应的行结束符。

例如:

java 复制代码
writer.write("第一行");
writer.newLine();

writer.write("第二行");
writer.newLine();

writer.write("第三行");

这样可以将内容写入不同的行中,而不必手动决定使用 \n 还是 \r\n。

6.4 缓冲流的应用

1.使用缓冲流读取文本文件

如果需要逐行读取文本文件,可以使用 BufferedReader。

为了避免字符编码问题,也可以通过 InputStreamReader 明确指定 UTF-8:

java 复制代码
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class Test {
    public static void main(String[] args) throws IOException {
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(
                        new FileInputStream("test.txt"),
                        StandardCharsets.UTF_8))) {

            String line;

            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        }
    }
}

这里将三个功能组合在一起:

  • FileInputStream:读取文件字节。
  • InputStreamReader:按照 UTF-8 将字节解码为字符。
  • BufferedReader:提供缓冲和按行读取能力。

2.使用缓冲流复制文件

复制图片或其他二进制文件时,可以使用 BufferedInputStream 和 BufferedOutputStream。

其基本流程是:

text 复制代码
1.创建文件输入流和输出流

2.使用缓冲流包装文件流

3.读取一批字节

4.写入目标文件

5.重复操作,直到文件末尾

6.关闭流,完成复制

这种方式能够减少频繁的小规模读写操作。

3.缓冲流与普通文件流的区别

对比项 普通文件流 缓冲流
主要作用 直接完成文件读写 在普通流基础上提供缓冲
缓冲能力 不一定提供额外的用户级缓冲 提供内部缓冲区
常见类 FileInputStream、FileOutputStream BufferedInputStream、BufferedOutputStream
文本处理便利性 需要自行组织读取逻辑 BufferedReader 支持 readLine()
使用方式 直接创建 通常包装其他流

缓冲流并不保证所有场景下都一定更快,但对于频繁的小规模 IO 操作,通常能够减少调用开销,提高处理效率。

7. 文件操作的综合应用

7.1 文件复制

1.文件复制的基本思路

文件复制的核心,就是从源文件读取数据,再将读取到的数据写入目标文件。

基本流程如下:

text 复制代码
1.确定源文件和目标文件

2.创建输入流和输出流

3.从源文件读取数据

4.将数据写入目标文件

5.重复读取和写入

6.关闭流,完成复制

需要注意,复制文件时应当根据文件类型选择合适的流。对于图片、视频等二进制文件,通常使用字节流。

2.使用字节流复制文件

下面以复制图片为例:

java 复制代码
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (FileInputStream input = new FileInputStream("source.jpg");
             FileOutputStream output = new FileOutputStream("copy.jpg")) {

            byte[] buffer = new byte[4096];
            int len;

            while ((len = input.read(buffer)) != -1) {
                output.write(buffer, 0, len);
            }
        }

        System.out.println("文件复制完成");
    }
}

这段代码中:

  • FileInputStream 负责读取源文件。
  • FileOutputStream 负责写入目标文件。
  • buffer 用于暂存读取到的数据。
  • len 表示本次实际读取的字节数。
  • write(buffer, 0, len) 只写出本次实际读取的数据。

为什么不直接写入整个数组?

因为最后一次读取时,实际读取的字节数可能小于数组长度。如果直接写入整个数组,就可能把上一次残留在数组中的数据也写入文件,造成文件内容错误。

因此,应当使用 len 指定本次实际写入的长度。

3.使用缓冲流优化文件复制

在前面的基础上,可以使用缓冲流包装文件流:

java 复制代码
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (BufferedInputStream input = new BufferedInputStream(new FileInputStream("source.jpg"));
             BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream("copy.jpg"))) {

            byte[] buffer = new byte[4096];
            int len;

            while ((len = input.read(buffer)) != -1) {
                output.write(buffer, 0, len);
            }
        }

        System.out.println("文件复制完成");
    }
}

与普通文件流相比,这里多了 BufferedInputStream 和 BufferedOutputStream。

它们能够减少频繁的小规模底层 IO 操作。对于实际项目,可以根据文件大小和性能要求选择合适的缓冲方式。

7.2 文件内容的读取与统计

1.逐行读取文件

在实际开发中,文本文件经常需要逐行读取,例如读取日志、配置内容或文本数据。

可以使用 BufferedReader 实现:

java 复制代码
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader("test.txt"))) {

            String line;

            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        }
    }
}

readLine() 每次读取一行文本,到达文件末尾时返回 null。

对于明确使用 UTF-8 编码的文本文件,建议使用指定字符集的读取方式,避免依赖平台默认编码。

2.统计文件行数

如果希望统计文本文件有多少行,可以在逐行读取时增加一个计数器。

java 复制代码
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        int count = 0;

        try (BufferedReader reader = new BufferedReader(new FileReader("test.txt"))) {

            while (reader.readLine() != null) {
                count++;
            }
        }

        System.out.println("文件行数:" + count);
    }
}

这里每成功读取一行,计数器就加一。

需要注意,按行统计得到的是读取到的文本行数,不一定等于文件中换行符的数量。例如,最后一行即使没有行结束符,也仍然可能被读取为一行。

3.统计文件中的字符或内容

如果希望统计文件中读取到的 UTF-16 代码单元数量,可以使用字符流:

java 复制代码
import java.io.FileReader;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        int count = 0;

        try (FileReader reader = new FileReader("test.txt")) {
            while (reader.read() != -1) {
                count++;
            }
        }

        System.out.println("代码单元数量:" + count);
    }
}

这里统计的是读取到的 char 代码单元数量,不一定等于用户感知的字符数量。

如果需要统计某个单词出现的次数、某个字符串出现的次数,或者统计不同类型字符的数量,就可以在读取过程中进一步添加相应的判断逻辑。

对于较大的文件,建议采用逐行或分批读取的方式,而不是一次性将全部内容加载到内存中。

7.3 目录遍历与文件查找

1.遍历指定目录

如果希望查看某个目录下有哪些文件和子目录,可以使用 listFiles()。

java 复制代码
import java.io.File;

public class Test {
    public static void main(String[] args) {
        File dir = new File("data");

        File[] files = dir.listFiles();

        if (files == null) {
            System.out.println("目录不存在,或无法读取目录内容");
            return;
        }

        for (File file : files) {
            System.out.println(file.getAbsolutePath());
        }
    }
}

这段代码只会遍历 data 目录中的直接子项。

2.根据文件名查找文件

例如,我们希望查找指定目录中所有以 .java 结尾的文件:

java 复制代码
import java.io.File;

public class Test {
    public static void main(String[] args) {
        File dir = new File(".");

        searchJavaFiles(dir);
    }

    public static void searchJavaFiles(File dir) {
        File[] files = dir.listFiles();

        if (files == null) {
            return;
        }

        for (File file : files) {
            if (file.isFile() && file.getName().endsWith(".java")) {
                System.out.println(file.getAbsolutePath());
            }
        }
    }
}

这段代码只会查找当前目录的直接子文件,不会自动进入子目录。

3.递归查找目录中的文件

如果希望查找当前目录及其所有子目录中的 .java 文件,可以将递归遍历结合起来:

java 复制代码
import java.io.File;

public class Test {
    public static void main(String[] args) {
        File dir = new File(".");

        searchJavaFiles(dir);
    }

    public static void searchJavaFiles(File dir) {
        File[] files = dir.listFiles();

        if (files == null) {
            return;
        }

        for (File file : files) {
            if (file.isFile() && file.getName().endsWith(".java")) {
                System.out.println(file.getAbsolutePath());
            } else if (file.isDirectory()) {
                searchJavaFiles(file);
            }
        }
    }
}

这里将文件查找和递归遍历结合起来,实现了对整个目录树的搜索。

到这里整篇文章就完结了。如果需要处理很深的目录或复杂的文件系统,也可以进一步学习 Java NIO 中的 Files.walk() 等 API。

相关推荐
Flynn Liang1 小时前
HikariCP 连接池不是越大越好:I/O 密集型 Java 服务的数据库容量工程
java·数据库·mysql·高并发·连接池·hikaricp·sql 优化
学长毕设1 小时前
基于SpringBoot社区快递驿站物流配送系统-附源码
java·spring boot·后端
starzy19901 小时前
深入理解Scala隐式参数:上下文流转
开发语言·python·scala
Flynt2 小时前
Java4Shell 实测:EPYC 一跑就中招,关掉 Base64 硬件加速,1KB 解码慢 14 倍
java·安全·性能优化
Resean02232 小时前
Spring 源码分析(七)AOP 原理(上):代理的创建
java·后端·spring
Tangq一定可以的2 小时前
Spring AI Advisor 详解 - 给大模型调用加上“切面“,日志/过滤/记忆一键搞定
java·后端·spring
feixing_fx2 小时前
JavaScript 是什么:从浏览器脚本到通用编程语言
开发语言·前端·javascript·前端框架·ecmascript
小巫编程室3 小时前
我造了一个 Java 能力包:让 AI 直接调用你的业务代码
java·前端·后端
深入云栈3 小时前
Netty 4.2.x 源码深度解析 (二十四):池化内存分配 —— PoolArena、PoolChunk 与 PoolSubpage
java·后端·架构