目录
一、文件基础
1、认识文件
我们先来认识狭义上的文件(file)。针对硬盘这种持久化存储的I/O设备，当我们想要进行数据保存时，往往不是保存成一个整体，而是独立成一个个的单位进行保存，这个独立的单位就被抽象成文件的概念，就类似办公桌上的一份份真实的文件一般。
文件除了有数据内容之外，还有一部分信息，例如文件名、文件类型、文件大小等并不作为文件的数据而存在，我们把这部分信息可以视为文件的元信息。
2、树型结构组织和目录
随着文件越来越多，对文件的系统管理方案也被提上了日程，如何进行文件的组织呢，一种合乎自然的想法出现了，就是按照层级结构进行组织(也就是我们数据结构中学习过的树形结构)。这样，一种专门用来存放管理信息的特殊文件诞生了，也就是我们平时所谓文件夹(folder)或者目录(directory)的概念。
3、文件路径
从树型结构的角度来看，树中的每个结点都可以被一条从根开始，一直到达的结点的路径所描述，而这种描述方式就被称为文件的绝对路径（absolute path）。
除了可以从根开始进行路径的描述，我们可以从任意结点出发，进行路径的描述，这种描述方式就被称为相对路径（relative path），相对于当前所在结点的一条路径。
4、其他知识
即使是普通文件，根据其保存数据的不同，也经常被分为不同的类型，我们一般简单的划分为文本文件和二进制文件，分别指代保存被字符集编码的文本和按照标准格式保存的非被字符集编码过的文件。
Windows操作系统会按照文件名中的后缀来确定文件类型以及该类型文件的默认打开程序。但这个习俗并不是通用的，在OSX、Unix、Linux等操作系统上，就没有这样的习惯，一般不对文件类型做如此精确地分类。
文件由于被操作系统进行了管理，所以根据不同的用户，会赋予用户不同的对待该文件的权限，一般地可以认为有可读、可写、可执行权限。
Windows操作系统上，还有一类文件比较特殊，就是平时我们看到的快捷方式（shortcut），这种文件只是对真实文件的一种引用而已。其他操作系统上也有类似的概念，例如，软链接（soft link）等。
最后，很多操作系统为了实现接口的统一性，将所有的I/O设备都抽象成了文件的概念，使用这一理念最为知名的就是Unix、Linux操作系统(万物皆文件)。
二、在JAVA中操作文件
1、方法介绍
Java通过java.io.File类来对一个文件（包括目录）进行抽象的描述。注意，有File对象，并不代表真实存在该文件。
我们先来看看File类中的常见属性、构造方法和方法。
- 常见属性
| 修饰符及类型 | 属性 | 说明 |
| static String | pathSeparator | 依赖于系统的路径分隔符，String类型的表示 |
| static char | pathSeparator | 依赖于系统的路径分隔符，char类型的表示 |
- 构造方法
| 签名 | 说明 |
| File(File parent, String child) | 根据父目录+孩子文件路径，创建一个新的File实例 |
| File(String pathname) | 根据文件路径创建一个新的File实例，路径可以是绝对路径或者相对路径 |
| File(String parent, String child) | 根据父目录+孩子文件路径，创建一个新的File实例，父目录用路径表示 |
- 方法
| 修饰符及返回值类型 | 方法签名 | 说明 |
| String | getParent() | 返回File对象的父目录文件路径 |
| String | getName() | 返回FIle对象的纯文件名称 |
| String | getPath() | 返回File对象的文件路径 |
| String | getAbsolutePath() | 返回File对象的绝对路径 |
| String | getCanonicalPath() | 返回File对象的修饰过的绝对路径 |
| boolean | exists() | 判断File对象描述的文件是否真实存在 |
| boolean | isDirectory() | 判断File对象代表的文件是否是一个目录 |
| boolean | isFile() | 判断File对象代表的文件是否是一个普通文件 |
| boolean | createNewFile() | 根据File对象,自动创建一个空文件。成功创建后返回true |
| boolean | delete() | 根据File对象，删除该文件。成功删除后返回true |
| void | deleteOnExit() | 根据File对象，标注文件将被删除，删除动作会到JVM运行结束时才会进行 |
| String[] | list() | 返回File对象代表的目录下的所有文件名 |
| File[] | listFiles() | 返回File对象代表的目录下的所有文件，以File对象表示 |
| boolean | mkdir() | 创建File对象代表的目录 |
| boolean | mkdirs() | 创建File对象代表的目录，如果必要，会创建中间目录 |
| boolean | renameTo(File dest) | 进行文件改名，也可以视为我们平时的剪切、粘贴操作 |
| boolean | canRead() | 判断用户是否对文件有可读权限 |
| boolean | canWrite() | 判断用户是否对文件有可写权限 |
2、代码示例
我们查看文件的各个信息：
import java.io.File;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
File f = new File("./test.txt");
System.out.println(f.getParent());
System.out.println(f.getName());
System.out.println(f.getPath());
System.out.println(f.getAbsolutePath());
System.out.println(f.getCanonicalPath());
}
}
查看一个文件是否存在，不存在就创建：
import java.io.File;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
File file = new File("E:/javaproject/Demo2/test.txt");
System.out.println(file.exists());
System.out.println(file.isDirectory());
System.out.println(file.isFile());
// 创建文件
boolean ret = file.createNewFile();
System.out.println("ret = " + ret);
System.out.println(file.exists());
System.out.println(file.isDirectory());
System.out.println(file.isFile());
}
}
删除文件：
import java.io.File;
public class Main {
public static void main(String[] args) throws InterruptedException {
File f = new File("D:/test.txt");
// boolean ret = f.delete();
// System.out.println("ret = " + ret);
f.deleteOnExit();
Thread.sleep(5000);
System.out.println("进程结束!");
}
}
返回File对象代表的目录下的所有文件名：
import java.io.File;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
File f = new File("E:/");
String[] files = f.list();
System.out.println(Arrays.toString(files));
}
}
创建目录：
import java.io.File;
public class Main {
public static void main(String[] args) {
File f = new File("d:/java/aaa/bbb/ccc");
// boolean ret = f.mkdir();
boolean ret = f.mkdirs();
System.out.println("ret = " + ret);
}
}
其他接口可以自己尝试一下，在此我们就不展开讲了。
三、文件内容的读写(数据流)
1、InputStream概述
- 方法
| 修饰符及返回值类型 | 方法签名 | 说明 |
| int | read() | 读取一个字节的数据，返回-1代表已经完全读完了 |
| int | read(byte[] b) | 最多读取b.length字节的数据到b中，返回实际读到的数量；-1代表已经读完了 |
| int | read(byte[] b, int off, int len) | 最多读取len-off字节的数据到b中，放在从off开始，返回实际读到的数量；-1代表已经读完了 |
| void | close() | 关闭字节流 |
- 说明
InputStream只是一个抽象类，要使用还需要具体的实现类。关于InputStream的实现类有很多，基本可以认为不同的输入设备都可以对应一个InputStream类，我们现在只关心从文件中读取，所以使用FileInputStream
2、FileInputStream概述
- 构造方法
| 签名 | 说明 |
| FileInputStream(File file) | 利用File构造文件输入流 |
| FileInputStream(String name) | 利用文件路径构造文件输入流 |
- 代码示例
将文件完全读完的两种方式。相比较而言，后一种的IO次数更少，性能更好。
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Main {
public static void main(String[] args) throws IOException {
try (InputStream is = new FileInputStream("test.txt")) {
while (true) {
int b = is.read();
if (b == -1) {
// 代表文件已经全部读完
break;
}
System.out.printf("%c", b);
}
}
}
}
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Main {
public static void main(String[] args) throws IOException {
try (InputStream is = new FileInputStream("test.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.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Main {
public static void main(String[] args) throws IOException {
try (InputStream is = new FileInputStream("test.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);
}
}
}
}
}
3、利用Scanner进行字符读取
上述例子中，我们看到了对字符类型直接使用InputStream进行读取是非常麻烦且困难的，所以我们使用一种我们之前比较熟悉的类来完成该工作，就是 Scanner 类。
| 构造方法 | 说明 |
| Scanner(InputStream is, String charset) | 使用charset字符集进行is的扫描读取 |
- 代码示例
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws IOException {
try (InputStream is = new FileInputStream("test.txt")) {
try (Scanner scanner = new Scanner(is, "UTF-8")) {
while (scanner.hasNext()) {
String s = scanner.next();
System.out.print(s);
}
}
}
}
}
4、OutputStream概述
- 方法
| 修饰符及返回值类型 | 方法签名 | 说明 |
| void | write(int b) | 写入要给字节的数据 |
| void | write(byte[] b) | 将b这个字符数组中的数据全部写入os中 |
| int | write(byte[] b, int off, int len) | 将b这个字符数组中从off开始的数据写入os中，一共写len个 |
| void | close() | 关闭字节流 |
| void | flush() | 刷新操作 |
- 说明
OutputStream同样只是一个抽象类，要使用还需要具体的实现类。我们现在还是只关心写入文件中，所以使用FileOutputStream。
OutputStream打开一个文件，默认就会清空文件的原有内容写入的数据，如果不想清空，就可以使用追加写的方式(在构造方法中第二个参数传入true)
我们知道I/O的速度是很慢的，所以大多的OutputStream为 了减少设备操作的次数，在写数据的时候都会将数据先暂时写入内存的一个指定区域里，直到该区域满了或者其他指定条件时才真正将数据写入设备中，这个区域一般称为缓冲区。但造成一个结果，就是我们写的数据，很可能会遗留一部分在缓冲区中。需要在最后或者合适的位置，调用flush（刷新）操作，将数据刷到设备中。
- 代码示例
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Main {
public static void main(String[] args) throws IOException {
try (OutputStream os = new FileOutputStream("test.txt")) {
os.write('H');
os.write('e');
os.write('l');
os.write('l');
os.write('o');
// 不要忘记 flush
os.flush();
}
}
}
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
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.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
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, 7);
// 不要忘记 flush
os.flush();
}
}
}
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
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.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
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();
}
}
}
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 (PrintWriter writer = new PrintWriter(os)) {
writer.println("我是第一行");
writer.print("我的第二行\r\n");
writer.printf("%d: 我的第三行\r\n", 1 + 1);
writer.flush();
}
}
}
}
6、使用Reader与Writer
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
// Reader
public class Main {
public static void main(String[] args) throws IOException {
try (Reader reader = new FileReader("test.txt")) {
while (true) {
char[] cbuf = new char[3];
int n = reader.read(cbuf);
if (n == -1) {
break;
}
System.out.println("n = " + n);
for (int i = 0; i < n; i++) {
System.out.println(cbuf[i]);
}
}
}
}
}
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class Main {
public static void main(String[] args) {
try (Writer writer = new FileWriter("test.txt", true)) {
// 直接使用 write 方法就可以写入数据.
writer.write("我在学习文件IO");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
四、编写一个程序，扫描目录下的所有文件
import java.io.File;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 1. 先让用户输入一个要扫描的目录
System.out.println("请输入要扫描的路径: ");
String path = scanner.next();
File rootPath = new File(path);
if (!rootPath.isDirectory()) {
System.out.println("您输入的扫描的路径有误!! ");
return;
}
// 2. 再让用户输入一个要查询的关键词.
System.out.println("请输入要删除文件的关键词: ");
String word = scanner.next();
// 3. 可以进行递归的扫描了.
// 通过这个方法进行递归.
scanDir(rootPath, word);
}
private static void scanDir(File rootPath, String word) {
// 1. 先列出 rootPath 中所有的文件和目录.
File[] files = rootPath.listFiles();
if (files == null) {
// 当前目录为 null, 就可以直接返回了.
return;
}
// 2. 遍历这里的每个元素, 针对不同类型做出不同的处理.
for (File f : files) {
// 加个日志, 方便观察当前递归的执行过程.
System.out.println("当前扫描的文件: " + f.getAbsolutePath());
if (f.isFile()) {
// 普通文件. 检查文件是否要删除. 并执行删除动作.
checkDelete(f, word);
} else {
// 目录. 递归的再去判定子目录里包含的内容
scanDir(f, word);
}
}
}
private static void checkDelete(File f, String word) {
if (!f.getName().contains(word)) {
// 不必删除, 直接方法结束
return;
}
// 需要删除
System.out.println("当前文件为: " + f.getAbsolutePath() + ", 请确认是否要删除(Y/n): ");
Scanner scanner = new Scanner(System.in);
String choice = scanner.next();
if (choice.equals("Y") || choice.equals("y")) {
// 真正执行删除操作
f.delete();
System.out.println("删除完毕!");
} else {
// 如果输入其他值, 不一定非得是 n, 都会取消删除操作.
System.out.println("取消删除!");
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
