1. 文件的概念
1.1 文件的定义:一个个独立的数据单位
狭义的文件:
指硬盘上的 文件 和 目录 。
广义的文件:
泛指计算机中的很多软硬件资源。
Java中的文件:
对于硬盘这种持久化存储的I/O设备,当进行数据保存时,往往不是保存成一个整体,而是独立成一个个的单位进行保存,这个独立的单位就被抽象成文件的概念, 就类似办公桌上的一份份真实的文件一般。
操作系统中把很多软硬件资源都抽象成了文件 ,按照文件得形式统一管理。
1.2 文件的构成:数据+元信息
文件中有数据内容,还有一部分文件属性信息,例如文件名、文件类型、文件大小等,并不作为文件中的数据而存在,我们把这部分信息可以视为文件的元信息。
1.3 文件的组织方式——目录
按照层级结构(树形结构)进行组织,形成了文件夹或者目录。
这是一种专门用来存放管理文件元信息的特殊文件。
1.4 文件的路径
每个文件在硬盘上都有一个具体的“路径”,可以使用 / 来分隔不同的目录级别。
有两种路径表示风格:
- 绝对路径
树中的每个结点都可以被一条从根开始,一直到达的结点的路径所描述,这种描述方式就被称为文件的绝对路径。- 相对路径
从任意结点出发,进行路径的描述,这种描述方式就被称为相对路径(relative path),相对于当前所在结点的一条路径。
1.5 文件的类型
- 文本文件:
经过字符集编码的文本,存的是文本,字符串。由字符串构成,每个字符串都是通过一个数组表示。
- 二进制文件:
按照标准格式保存的没有被字符集编码过的文件,存的是二进制数据,不一定是字符串,存储内容没有限制,可以存储任何数据。
(了解:)
快捷方式,软链接等:
Windows 操作系统上,还有一类文件比较特殊,
就是平时我们看到的快捷方式(shortcut),
这种文件 只是对真实文件的一种引用而已。
其他操作系统上也有类似的概念,例如,软链接(soft link)等。
I/O 设备都抽象:
很多操作系统为了实现接口的统一性,
将所有的 I/O 设备都抽象成了文件的概念,
使用这一理念 最为知名的就是 Unix、Linux 操作系统 —— 万物皆文件。
2. File类
Java 中通过 java.io.File 类来对一个文件包括目录进行抽象的描述。
有 File 对象并不 代表真实存在该文件。
2.1 File类的属性
parent:表示当前文件所在的目录。
child:自身的文件名
2.2 构造方法
2.3 常用方法:
2.4 案例综合
2.4.1 观察 get 系列的特点和差异
// 观察 get 系列的特点和差异
public class IODemo1 {
public static void main(String[] args) throws IOException {
File file = new File("./test.txt");
System.out.println(file.getName()); // File对象的纯文件名称
System.out.println(file.getParent()); // File对象的父文件路径
System.out.println(file.getPath()); // File对象的文件路径
System.out.println(file.getAbsolutePath()); // File对象的绝对路径
System.out.println(file.getCanonicalPath()); // File对象修饰过的绝对路径
}
}
------------------------------------------------
// 运行结果
test.txt // File对象的纯文件名称
. // File对象的父文件路径
.\test.txt // File对象的文件路径
D:\code\test_java\java-0628-1\.\test.txt // File对象的绝对路径
D:\code\test_java\java-0628-1\test.txt // File对象修饰过的绝对路径
Process finished with exit code 0
2.4.2 普通文件的创建、删除
// 普通文件的创建、删除
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()); // 判断File对象描述的文件是否真实存在 false
System.out.println(file.isDirectory()); // 判断File对象代表的文件是否是一个目录 false
System.out.println(file.isFile()); // 判断File对象代表的文件是否是一个普通文件 false
System.out.println(file.createNewFile()); // 根据File对象创建一个空文件,成功后返回true 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
true
true
false
true
false
2.4.3 普通文件的删除
// 普通文件的删除
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()); // 根据File对象删除该文件,成功后返回true true
System.out.println(file.exists()); // false 文件已删除不存在(但是这个File对象依然存在)
}
}
-----------------------------------------------
false
true
true
true
false
### 2.4.4 观察 deleteOnExit 的现象
// 观察 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()); // false
System.out.println(file.createNewFile()); // true
System.out.println(file.exists()); // true
file.deleteOnExit(); // 根据File对象,标注文件将被删除,删除动作在JVM运行结束时才会进行
System.out.println(file.exists()); // true 此时JVM还在运行
}
}
-------------------------------------------------------------
// 运行结果
false
true
true
true
----------------------------------------
程序运行结束后,文件还是被删除了
2.4.5 观察目录的创建
// 观察目录的创建
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()); // 创建File对象代表的目录,成功后返回true true
System.out.println(dir.isDirectory()); // true
System.out.println(dir.isFile()); // false
}
}
------------------------------------------------------------------
// 运行结果
false
false
true
true
false
2.4.6 观察目录创建2
//观察目录创建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()); // false
System.out.println(dir.isFile()); // fasle
System.out.println(dir.mkdir()); // 创建File对象代表的目录,但是不会创建中间目录
System.out.println(dir.isDirectory()); // false
System.out.println(dir.isFile()); // false
}
}
--------------------------------------------------------
// 运行结果
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()); // false
System.out.println(dir.isFile()); // false
System.out.println(dir.mkdirs()); // 创建File对象代表的目录,会创建中间目录
System.out.println(dir.isDirectory()); // false
System.out.println(dir.isFile()); // fasle
}
}
----------------------------------------------------------------
// 运行结果
false
false
true
true
false
2.4.7 观察文件重命名
// 观察文件重命名
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()); // true
System.out.println(dest.exists()); // true
}
}
-----------------------------------------------------------------
// 运行结果
true
false
true
false
true
3. 字节流
Java用流实现了输入与输出操作,并提供了统一的接口,使程序设计更为简单。
输入还是输出是相对于内存的。
把数据读到内存中称为输入,即input,进行数据的read操作。
从内存往外部设备写数据,称为输出,即output,即数据的write操作。
3.1 读取文件——InputStream 类
InputStream 只是一个抽象类,要使用还需要具体的实现类,InputStream 的实现类有很多,我们只关心从文件中读取所以使用FileInputStream类。
3.1.2 FileInputStream
3.1.2.1 常用方法
3.1.2.2 构造方法
3.1.2.1 按字节进行数据读
try (InputStream is = ...) {
byte[] buf = new byte[1024];
while (true) {
int n = is.read(buf);
if (n == -1) {
break;
}
// buf 的 [0, n) 表示读到的数据,按业务进行处理
}
}
3.1.2.2 按字符进行数据读
// 示例
try (InputStream is = ...) {
try (Scanner scanner = new Scanner(is, "UTF-8")) {
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
// 根据 line 做业务处理
}
}
}
3.1.2.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(); // 一次最多读取8个byte
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); // 一次最多读取1024个byte放在字节数组buf中,返回的是读取到byte的个数
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);
}
}
}
}
}
3.1.2.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")) { // 创建一个FileInputStream对象
try (Scanner scanner = new Scanner(is, "UTF-8")) { // 用Scanner类对象对FileInputStream对象进行读取
while (scanner.hasNext()) {
String s = scanner.next();
System.out.print(s);
}
}
}
}
}
3.2 输出文件——OutputStream 类
OutputStream 同样只是一个抽象类,要使用还需要具体的实现类,我们现在还是只关心写入文件中,所以使用 FileOutputStream。
3.2.1 OutputStreamWriter
3.2.1.1 常用方法
3.2.1.2 代码示例
// 示例一:
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.2.1.3 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();
}
}
}
}
}
3.2.1.4 按字符进行数据写
// 示例
try (OutputStream os = ...) {
try (OutputStreamWriter osWriter = new OutputStreamWriter(os, "UTF-8")) {
try (PrintWriter writer = new PrintWriter(osWriter)) {
while (/* 还有未完成的业务数据 */) {
writer.println(...);
}
writer.flush(); // 进行数据刷新操作
}
}
}
3.2.1.5 按字节进行数据写
// 示例
try (OutputStream os = ...) {
byte[] buf = new byte[1024];
while (/* 还有未完成的业务数据 */) {
// 将业务数据填入 buf 中,长度为 n
int n = ...;
os.write(buf, 0, n);
}
os.flush(); // 进行数据刷新操作
}
4. 小程序练习
- 扫描指定目录,并找到名称中包含指定字符的所有普通文件(不包含目录)
// 示例:扫描指定目录,并找到名称中包含指定字符的所有普通文件(不包含目录),
// 并且后续询问用户是否要删除该文件。
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());
}
}
}
}
}
- 进行普通文件的复制
// 示例:进行普通文件的复制
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<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;
}
}