Java——文件操作IO
一 、文件File
狭义的文件：
指硬盘上的 文件 和 目录 。
广义的文件：
泛指计算机中的很多软硬件资源。
针对硬盘这种持久化存储的I/O设备，当我们想要进行数据保存时，
往往不是保存成一个整体，而是独立成一个个的单位进行保存，
这个独立的单位就被抽象成文件的概念， 就类似办公桌上的一份份真实的文件一般。
操作系统中把很多软硬件资源都抽象成了文件 ，按照文件得形式统一管理。
文件除了有数据内容之外，还有一部分信息。
例如文件名、文件类型、文件大小等并不作为文件的数据而存在，
我们把这部分信息可以视为文件的元信息。
二 、文件的结构组织和目录
按照层级结构进行组织——树形结构，
形成了文件夹或者目录。
这是一种专门用来存放管理文件元信息的特殊文件。
三 、文件路径
每个文件在硬盘上都有一个具体的“路径”，
可以使用 / 来分隔不同的目录级别。
有两种路径表示风格。
1. 绝对路径
树中的每个结点都可以被一条从根开始，
一直到达的结点的路径所描述，
而这种描述方式就被称为文件的绝对路径。
2. 相对路径
从任意结点出发，进行路径的描述，
而这种描述方式就被称为相对路径（relative path），
相对于当前所在结点的一条路径。
三 、文件的类型
一般简单的划分为 文本文件 和 二进制文件。
分别指代保存 被字符集编码的文本 和 按照标准格式保存的非被字符集编码过的文件。
-
文本文件（存的是文本，字符串）： 由字符串构成，每个字符串都是通过一个数组表示。
-
二进制文件（存的是二进制数据，不一定是字符串）：没有限制，可以存储任何数据。
Windows 操作系统上，还有一类文件比较特殊，
就是平时我们看到的快捷方式（shortcut），
这种文件 只是对真实文件的一种引用而已。
其他操作系统上也有类似的概念，例如，软链接（soft link）等。
很多操作系统为了实现接口的统一性，
将所有的 I/O 设备都抽象成了文件的概念，
使用这一理念 最为知名的就是 Unix、Linux 操作系统 —— 万物皆文件。
四 、 File类
Java 中通过 java.io.File 类来对一个文件包括目录进行抽象的描述。
注意，有 File 对象，并不 代表真实存在该文件。
1. 属性
parent：表示当前文件所在的目录。
child：自身的文件名
2. 构造方法
3. 方法：
五 、代码示例
// 观察 get 系列的特点和差异
public class IODemo1 {
public static void main(String[] args) throws IOException {
File file = new File("./test.txt");
System.out.println(file.getName());
System.out.println(file.getParent());
System.out.println(file.getPath());
System.out.println(file.getAbsolutePath());
System.out.println(file.getCanonicalPath());
}
}
------------------------------------------------
// 运行结果
test.txt
.
.\test.txt
D:\code\test_java\java-0628-1\.\test.txt
D:\code\test_java\java-0628-1\test.txt
Process finished with exit code 0
// 普通文件的创建、删除
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());
System.out.println(file.isDirectory());
System.out.println(file.isFile());
System.out.println(file.createNewFile());
System.out.println(file.exists());
System.out.println(file.isDirectory());
System.out.println(file.isFile());
System.out.println(file.createNewFile());
}
}
--------------------------------------------------------------------------
false
false
false
true
true
false
true
false
// 普通文件的删除
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());
System.out.println(file.createNewFile());
System.out.println(file.exists());
System.out.println(file.delete());
System.out.println(file.exists());
}
}
-----------------------------------------------
false
true
true
true
false
// 观察 deleteOnExit 的现象
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());
System.out.println(file.createNewFile());
System.out.println(file.exists());
file.deleteOnExit();
System.out.println(file.exists());
}
}
-------------------------------------------------------------
// 运行结果
false
true
true
true
----------------------------------------
程序运行结束后，文件还是被删除了
// 观察目录的创建
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());
System.out.println(dir.isFile());
System.out.println(dir.mkdir());
System.out.println(dir.isDirectory());
System.out.println(dir.isFile());
}
}
------------------------------------------------------------------
// 运行结果
false
false
true
true
false
//观察目录创建2
import java.io.File;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
File dir = new File("some-parent\\some-dir"); // some-parent 和 some-
dir 都不存在
System.out.println(dir.isDirectory());
System.out.println(dir.isFile());
System.out.println(dir.mkdir());
System.out.println(dir.isDirectory());
System.out.println(dir.isFile());
}
}
--------------------------------------------------------
// 运行结果
false
false
false
false
false
*************************************************************
// mkdir() 的时候，如果中间目录不存在，则无法创建成功;
// mkdirs() 可以解决这个问题。
import java.io.File;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
File dir = new File("some-parent\\some-dir"); // some-parent 和 some-
dir 都不存在
System.out.println(dir.isDirectory());
System.out.println(dir.isFile());
System.out.println(dir.mkdirs());
System.out.println(dir.isDirectory());
System.out.println(dir.isFile());
}
}
----------------------------------------------------------------
// 运行结果
false
false
true
true
false
// 观察文件重命名
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());
System.out.println(dest.exists());
System.out.println(file.renameTo(dest));
System.out.println(file.exists());
System.out.println(dest.exists());
}
}
-----------------------------------------------------------------
// 运行结果
true
false
true
false
true
五 、 文件操作——流对象
以CPU为中心，
数据朝着CPU的方向流向就是输入，
所以把数据从硬盘到内存的这个过程成为读 input。
数据远离CPU的方向流向就是输出，
所以把数据从内存到硬盘这个过程称为写 output。
六 、 InputStream 类
InputStream 只是一个抽象类，要使用还需要具体的实现类。
关于 InputStream 的实现类有很多，
基本 可以认为不同的输入设备都可以对应一个InputStream 类
1. 方法
2. FileInputStream
构造方法
3. 使用示例
- 将文件完全读完的两种方式
import java.io.*;
// 需要先在项目目录下准备好一个 hello.txt 的文件，里面填充 "Hello" 的内容
public class Main {
public static void main(String[] args) throws IOException {
try (InputStream is = new FileInputStream("hello.txt")) {
while (true) {
int b = is.read();
if (b == -1) {
// 代表文件已经全部读完
break;
}
System.out.printf("%c", b);
}
}
}
}
// 相比较而言，这一种的 IO 次数更少，性能更好。
import java.io.*;
// 需要先在项目目录下准备好一个 hello.txt 的文件，里面填充 "Hello" 的内容
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]);
}
}
}
}
}
-
这里我们把文件内容中填充中文看看，注意，写中文的时候使用 UTF-8 编码。
hello.txt 中填写 “你好中国”。注意：这里利用了这几个中文的 UTF-8 编码后长度刚好是 3 个字节和长度不超过 1024 字节的现状，
但这种方式并不是通用的。
import java.io.*;
// 需要先在项目目录下准备好一个 hello.txt 的文件，里面填充 "你好中国" 的内容
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;
}
// 每次使用 3 字节进行 utf-8 解码，得到中文字符
// 利用 String 中的构造方法完成
// 这个方法了解下即可，不是通用的解决办法
for (int i = 0; i < len; i += 3) {
String s = new String(buf, i, 3, "UTF-8");
System.out.printf("%s", s);
}
}
}
}
}
4. 利用 Scanner 进行字符读取
上述例子中，对字符类型直接使用 InputStream 进行读取是非常麻烦且困难的，
所以使用一种我们之前比较熟悉的类来完成该工作，
就是 Scanner 类。
// 示例：
import java.io.*;
import java.util.*;
// 需要先在项目目录下准备好一个 hello.txt 的文件，里面填充 "你好中国" 的内容
public class Main {
public static void main(String[] args) throws IOException {
try (InputStream is = new FileInputStream("hello.txt")) {
try (Scanner scanner = new Scanner(is, "UTF-8")) {
while (scanner.hasNext()) {
String s = scanner.next();
System.out.print(s);
}
}
}
}
}
5. 按字节进行数据读
try (InputStream is = ...) {
byte[] buf = new byte[1024];
while (true) {
int n = is.read(buf);
if (n == -1) {
break;
}
// buf 的 [0, n) 表示读到的数据，按业务进行处理
}
}
6. 按字符进行数据读
// 示例
try (InputStream is = ...) {
try (Scanner scanner = new Scanner(is, "UTF-8")) {
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
// 根据 line 做业务处理
}
}
}
七 、OutputStream 类
OutputStream 同样只是一个抽象类，
要使用还需要具体的实现类。
我们现在还是只关心写入文件中，
所以使用 FileOutputStream。
1. 方法
2. OutputStreamWriter
// 示例
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException {
try (OutputStream os = new FileOutputStream("output.txt")) {
os.write('H');
os.write('e');
os.write('l');
os.write('l');
os.write('o');
// 不要忘记 flush
os.flush();
}
}
}
// 示例
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException {
try (OutputStream os = new FileOutputStream("output.txt")) {
byte[] b = new byte[] {
(byte)'G', (byte)'o', (byte)'o', (byte)'d'
};
os.write(b);
// 不要忘记 flush
os.flush();
}
}
}
// 示例
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException {
try (OutputStream os = new FileOutputStream("output.txt")) {
byte[] b = new byte[] {
(byte)'G', (byte)'o', (byte)'o', (byte)'d', (byte)'B',
(byte)'a', (byte)'d'
};
os.write(b, 0, 4);
// 不要忘记 flush
os.flush();
}
}
}
// 示例
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException {
try (OutputStream os = new FileOutputStream("output.txt")) {
String s = "Nothing";
byte[] b = s.getBytes();
os.write(b);
// 不要忘记 flush
os.flush();
}
}
}
// 示例
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException {
try (OutputStream os = new FileOutputStream("output.txt")) {
String s = "你好中国";
byte[] b = s.getBytes("utf-8");
os.write(b);
// 不要忘记 flush
os.flush();
}
}
}
3. 按字节进行数据写
// 示例
try (OutputStream os = ...) {
byte[] buf = new byte[1024];
while (/* 还有未完成的业务数据 */) {
// 将业务数据填入 buf 中，长度为 n
int n = ...;
os.write(buf, 0, n);
}
os.flush(); // 进行数据刷新操作
}
4. 按字符进行数据写
// 示例
try (OutputStream os = ...) {
try (OutputStreamWriter osWriter = new OutputStreamWriter(os, "UTF-8")) {
try (PrintWriter writer = new PrintWriter(osWriter)) {
while (/* 还有未完成的业务数据 */) {
writer.println(...);
}
writer.flush(); // 进行数据刷新操作
}
}
}
5. PrintWriter
上述，我们其实已经完成输出工作，但总是有所不方便，
我们接来下将 OutputStream 处理下，使用 PrintWriter 类来完成输出，
因为PrintWriter 类中提供了我们熟悉的 print/println/printf 方法。
// 示例
OutputStream os = ...;
OutputStreamWriter osWriter = new OutputStreamWriter(os, "utf-8"); // 告诉它，我们
的字符集编码是 utf-8 的
PrintWriter writer = new PrintWriter(osWriter);
// 接下来我们就可以方便的使用 writer 提供的各种方法了
writer.print("Hello");
writer.println("你好");
writer.printf("%d: %s\n", 1, "没什么");
// 不要忘记 flush
writer.flush();
// 示例
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();
}
}
}
}
}
八 、小程序练习
// 示例：扫描指定目录，并找到名称中包含指定字符的所有普通文件（不包含目录），
// 并且后续询问用户是否要删除该文件。
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 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 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());
}
}
}
}
}
// 示例：进行普通文件的复制
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 sourcePath = scanner.next();
File sourceFile = new File(sourcePath);
if (!sourceFile.exists()) {
System.out.println("文件不存在，请确认路径是否正确");
return;
}
if (!sourceFile.isFile()) {
System.out.println("文件不是普通文件，请确认路径是否正确");
return;
}
System.out.print("请输入要复制到的目标路径（绝对路径 OR 相对路径): ");
String destPath = scanner.next();
File destFile = new File(destPath);
if (destFile.exists()) {
if (destFile.isDirectory()) {
System.out.println("目标路径已经存在，并且是一个目录，请确认路径是否正
确");
return;
}
if (destFile.isFile()) {
System.out.println("目录路径已经存在，是否要进行覆盖？y/n");
String ans = scanner.next();
if (!ans.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);
}
os.flush();
}
}
System.out.println("复制已完成");
}
}
// 示例：扫描指定目录，并找到名称或者内容中包含指定字符的所有普通文件（不包含目录）。
注意：我们现在的方案性能较差，所以尽量不要在太复杂的目录下或者大文件下实验。
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 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 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;
}
}