JAVAEE初阶第四节——文件操作与IO

系列文章目录

JAVAEE初阶第四节——文件操作与IO

文件操作与IO

1. 认识文件
2. 树型结构组织和目录
3. Java 中操作文件
4. 代码示例
5. 文件内容的读写 —— 数据流
6. 线程安全的集合类
7. 练习

---

一.认识文件

首先认识下狭义上的文件(file)。针对硬盘这种持久化存储的I/O设备，当我们想要进行数据保存时， 往往不是保存成一个整体，而是独立成一个个的单位进行保存，这个独立的单位就被抽象成文件的概念。

文件除了有数据内容之外，还有一部分信息，例如文件名、文件类型、文件大小等并不作为文件的数据而存在，就把这部分信息可以视为文件的元信息。

二.树型结构组织和目录

同时，随着文件越来越多，对文件的系统管理也被提上了日程，如何进行文件的组织呢，一种合乎自然的想法出现了，就是按照层级结构进行组织 —— 也就是数据结构中学习过的树形结构。这样，一种专门用来存放管理信息的特殊文件诞生了，也就是平时所谓文件夹(folder)或者目录(directory)的概念。

1. 文件路径（Path）

如何在文件系统中如何定位我们的一个唯一的文件就成为当前要解决的问题，但这难不倒计算机科学家，因为从树型结构的角度来看，树中的每个结点都可以被一条从根开始，一直到达的结点的路径所描述，而这种描述方式就被称为文件的绝对路径（absolute path）。

路径有两种不同的格式：

1. 绝对路径：绝对路径，指的就是从树根节点出发(Windows是盘符)，一层一层最终到达目标文件。例如：D : \Users\Test1\test.txt
2. 相对路径：先指定人个"当前目录"/工作目录”/"基准目录，从当前目录出发，找到目标文件。例如目前已经在Users这个目录了此时相对路径就是…Test1\test.txt

2.其他知识

即使是普通文件，根据其保存数据的不同，也经常被分为不同的类型，一般简单的划分为文本文件和二进制文件，分别指代保存被字符集编码的文本和按照标准格式保存的非被字符集编码过的文件

Windows 操作系统上，会按照文件名中的后缀来确定文件类型以及该类型文件的默认打开程序。但这个习俗并不是通用的，在 OSX、Unix、Linux 等操作系统上，就没有这样的习惯，一般不对文件类型做如此精确地分类。

文件由于被操作系统进行了管理，所以根据不同的用户，会赋予用户不同的对待该文件的权限，一般可以认为有可读、可写、可执行权限。

Windows 操作系统上，还有一类文件比较特殊，就是平时看到的快捷方式（shortcut），这种文件只是对真实文件的一种引用而已。其他操作系统上也有类似的概念，例如，软链接（soft link）等

最后，很多操作系统为了实现接口的统一性，将所有的 I/O 设备都抽象成了文件的概念，使用这一理念 。
最为知名的就是 Unix、Linux 操作系统 —— 万物皆文件。

三.Java 中操作文件）

Java 中通过 java.io.File 类（在java.io包中）来对一个文件（包括目录）进行抽象的描述。注意，有 File 对象，并不代表真实存在该文件。

Java对于文件操作的API：
1.针对文件系统的操作。包括不限于，创建文件，删除文件，重命名文件，列出目录内容…
2.针对文件内容的操佾。读文件/写文件.

1. File 概述

先来看看 File 类中的常见属性、构造方法和方法

1.1 属性

修饰符及类型	属性	说明
static String	pathSeparator	依赖于系统的路径分隔符，String 类型的表示
static char	pathSeparator	依赖于系统的路径分隔符，char 类型的表示

1.2 构造方法

签名	说明
File(File parent, String child)	根据父目录 + 孩子文件路径，创建一个新的 File 实例
File(String pathname)	根据文件路径创建一个新的 File 实例，路径可以是绝对路径或者 相对路径
File(String parent, String child)	根据父目录 + 孩子文件路径，创建一个新的 File 实例，父目录用 路径表示

File(String pathname)的指定的路径（可以不存在）如果是相对路径：
（1）如果是直接在idea中运行程序，此时工作目录就是项目所在目录。
（2）如果是把代码打包成一个单独的jar包来执行，此时工作目录就是jar包所在目录

1.3 方法

修饰符及返回 值类型	方法签名	说明
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()	判断用户是否对文件有可写权限

四.代码示例

1. 观察 get 不同方法的特点和差异

public static void main(String[] args) throws IOException {
	File file = new File("D://Users/Test1/test.test");//构造FILe对象使用绝对路径
	System.out.println(file.getParent());//返回 File 对象的父目录文件路径
	System.out.println(file.getName());//返回 FIle 对象的纯文件名称
	System.out.println(file.getPath());//返回 File 对象的文件路径
	System.out.println(file.getAbsolutePath());//返回 File 对象的绝对路径
	System.out.println(file.getCanonicalPath());//返回 File 对象的修饰过的绝对路径(会抛出一个IOException异常)
}

如果构造FILe对象使用绝对路径，此时最后三个操作确实没啥区别。

但是如果构造FILe对象使用相对路径，结果就不一样了

getParent（）得到 . 是因为构造方法中的父目录文件路径就是.
getName()不变
getPath（）就和File构造方法中的参数一样了
getAbsolutePath（）中 . 表示当前的路径，此处是先一层一层找到Test这一级目录，然后再找 . 此时就是Test（原地踏步了一下）
getCanonicalPath（）得到的路径就是针对上面的绝对路径整理化简之后的效果了。

2.观察文件是否存在，判断文件是否是普通文件，判断文件是否是一个目录和普通文件的创建

public static void main(String[] args) throws IOException {
	File file = new File("./test.txt");
	System.out.println(file.exists());//判断文件是否存在
	System.out.println(file.isFile());//判断文件是否是普通文件
	System.out.println(file.isDirectory());//判断文件是否是一个目录

	boolean ret = file.createNewFile();//创建文件（会抛出IOException异常）
	System.out.println("是否成功创建文件 ：" + ret);
}

第一次运行程序:
exists( )：返回false，因为当前java项目所在的目录中没有叫test的txt文件
isFile（）：返回false，因为当前java项目所在的目录中叫test的txt文件不存在，所以不是文件
isDirectory：返回false，因为当前java项目所在的目录中叫test的txt文件不存在，所以不是目录
createNewFile（）：返回false或者抛出IOException异常，说明创建文件失败。返回true说明创建成功。（不能创建两个同名文件（在一个计算机上，文件的路径必须是唯一的））
第二次运行：

3. 普通删除文件

public static void main(String[] args) {
	File file = new File("./test.txt");
	boolean flag = file.delete();
	System.out.println("文件是否删除成功： " + flag);
}

delete（）：返回false，说明创建文件失败。返回true说明创建成功。

再次执行程序，因为文件已经被删除，所以返回false。

4. 退出时再删除文件

public static void main(String[] args) throws InterruptedException {  
		File file = new File("./test.txt");  
		System.out.println(file.exists());  
		System.out.println(file.exists());  
		file.deleteOnExit();//直到程序退出再删除  
		System.out.println(file.exists());  
		System.out.println(file.exists());  
}

执行程序，程序结束后，文件才被删除了

退出之后再删除，这样的文件，也称为"临时文件“。
例如，像word，Excel这样的程序就会把你正在编辑的内容写入到这个临时文件（一般情况下看不见）。作用：给你实时编辑的内容进行保存。防止出现你文件没保存，电脑突然断电的情况。
这时候如果突然断电，临时文件就仍然存在。借助这个临时文件就可以恢复之前未保存的数据。

5. 显示File 对象代表的目录下的所有文件名和以 File 对象 表示（所有文件名）

public static void main(String[] args) {
	File file = new File(".");//当前项目所在目录
	String[]  files = file.list();//File 对象代表的目录下的所有文件名
	File[] files2 = file.listFiles();//File 对象代表的目录下的所有文件，以 File 对象表示
	System.out.println(Arrays.toString(files));
	System.out.println(Arrays.toString(files2));
}

6. 观察目录的创建(mkdir和mkdirs)

public static void main(String[] args) {  
	File file = new File("./2a");//当前项目所在目录  
	boolean flag = file.mkdir();//需要再构造方法中把路径创建好，再通过mkdir来创建  
	System.out.println("文件是否创建成功： " + flag);  
}

mkdir：需要再构造方法中把路径创建好，再通过mkdir来创建(和普通文件创建一样有返回值)
当创建的是多级目录时就不能使用mkdir。

public static void main(String[] args) {  
	File file = new File("./2a/9s/2b");//当前项目所在目录  
	boolean flag = file.mkdir();//需要再构造方法中把路径创建好，再通过mkdir来创建  
	System.out.println("文件是否创建成功： " + flag);  
}

这个时候就要使用mkdirs

public static void main(String[] args) {  
	File file = new File("./2a/9s/2b");//当前项目所在目录  
	boolean flag = file.mkdirs();//需要再构造方法中把路径创建好，再通过mkdir来创建 
	System.out.println("文件是否创建成功： " + flag);  
}

7.观察文件重命名（也可以视为我们平时的剪切、粘贴操作）

1. 文件重命名
   

public static void main(String[] args) {  
	File prev = new File("./test.txt");  
	File cur = new File("./test22.txt");  
	prev.renameTo(cur);//将prev文件名称改为cur文件的名称  
}

文件名发生改变：

2. 文件移动
   

public static void main(String[] args) {  
	File prev = new File("./test22.txt");  
	File cur = new File("./2a/test22.txt");  
	prev.renameTo(cur);//将prev文件名称移动到cur文件中  
}

平时如果复制一个大的文件，比较消耗时间的。如果是移动一个大的文件，比较快速的（前提是得再同一个硬盘上），此时移动就只是简单的重命名(时间复杂度0 (1) )。

五.文件内容的读写 —— 数据流）

流是操作系统提供的概念，C/Java也好才能够基于流进行封装。

Java标准库对于流进行了一系列的封装，提供了一组类来负责进行这些工作。
针对这么多类，可以大体分成两个大类别：

1. 字节流：以字节为单位进行读写。一次最少读写一个字节
   代表类：
   InputStream - 输入
   OutputStream - 输出
2. 字符流：以字符为单位进行读写了。比如，如果是utf8表示汉字，3个字节就是一个汉字。每次读写都得以3个字节为单位（一个汉字为单位）来进行读写，不能一次读写半个汉字。

文件流读写文件内容在各种编程语言中，都是"固定套路"：
1)打开文件
2)关闭文件
3)读文件
4)写文件

1. InputStream 概述入

1.1 方法

修饰符及返回值类型	方法签名	说明
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()	关闭字节流

第三个方法中的off->offset偏移量，而不是关闭.

说明:
InputStream 只是一个抽象类，要使用还需要具体的实现类。关于 InputStream 的实现类有很多，基本可以认为不同的输入设备都可以对应一个 InputStream 类，现在只关心从文件中读取，所以使用 FileInputStream.

2. FileInputStream 概述

2.1 构造方法

签名	说明
FileInputStream(File file)	利用 File 构造文件输入流
FileInputStream(String name)	利用文件路径构造文件输入流

3. 代码示例

3.1 示例 1 - 按照字节读取（一次一个字节）

public static void main(String[] args) throws IOException {
	try(InputStream inputStream = new FileInputStream("./test.txt")) {
		while (true) {
			int n = inputStream.read();
			if (n == -1) break;
			System.out.printf("%x ", n);//16进制打印
		}
	}
}

关闭文件的重要性（文件资源泄露，内存泄露）：

（1）InputStream是抽象类， 不能直接创建这个类的实例。而是要创建一个它的子类FileInputStream（）抛出 （FileNotFoundException异常，是IOException的子类） 。创建对象的过程，就是打开文件的过程。（InputStream没有说明从哪里读取，FileInputStream就说明了从文件来读取）
（2）java 中try操作还提供了一个版本，try with resources。一旦代码出了try代码块，此时try自动帮咱们调用inputStream的close。（实现了Closeable接口的类，才能放到try（）里面）

3.2 示例 2- 按照字节读取（一次若干个字节）

一次读若干字节，要比一次读一个字节来的更高效

public static void main(String[] args) throws IOException {
	try(InputStream inputStream = new FileInputStream("./test.txt")) {
		while (true) {
			byte[] buffer = new byte[2023];
			int n = inputStream.read(buffer);
			if (n == -1) break;;//文件读取完毕了
			for (int i = 0; i < n; i++) {
				System.out.printf("%x ", buffer[i]);
			}
		}
	}
}

3.3 示例 3

public static void main(String[] args) throws IOException {
	try(InputStream inputStream = new FileInputStream("./test.txt")) {
		while (true) {
			byte[] buffer = new byte[2023];
			int n = inputStream.read(buffer);
			if (n == -1) break;;//文件读取完毕了
			String str = new String(buffer, 0, n);//buffer数组的0-n构造成string
			System.out.printf(str);
		}
	}
}

4. OutputStream 概述

4.1 方法

修饰符及返回 值类型	方法签名	说明
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()	重要：我们知道 I/O 的速度是很慢的，所以，大多的 OutputStream 为了减少设备操作的次数，在写数据的时候都会将数据先暂时写入内存的一个指定区域里，直到该区域满了或者其他指定条件时才真正将数据写入设备中，这个区域一般称为缓冲区。但造成一个结果，就是我们写的数据，很可能会遗留一部分在缓冲区中。需要在最后或者合适的位置， 调用 flush（刷新）操作，将数据刷到设备中。

说明

OutputStream 同样只是一个抽象类，要使用还需要具体的实现类。现在还是只关心写入文件中， 所以使用 FileOutputStream.

4.2 利用 OutputStreamWriter 进行字符写入

4.2.1 示例一 默认写（清空）

public static void main(String[] args) throws IOException {
	try (OutputStream outputStream = new FileOutputStream("./test.txt")) {
		byte[] buffer = new byte[]{ 102,101,100,99,98,97 };
		outputStream.write(buffer);
	}
}

OutputStream默认情况下，会把之前文件的内容都清空掉，然后从头重新写！（清空）
清空操作是在使用OutputStream打开时就进行的，即使没有写入具体内容也会清空。

4.2.2 示例二 追加写

public static void main(String[] args) throws IOException {
	try (OutputStream outputStream = new FileOutputStream("./test.txt")) {
		byte[] buffer = new byte[]{ 102,101,100,99,98,97 };
		outputStream.write(buffer);
	}
}

5. 使用Reader和Writer字符流读写文件

5.1 使用Reader字符流读文件

和InputStream的方法类似,但是是以char为单位。

public static void main(String[] args) throws IOException {
	try (Reader reader = new FileReader("./test.txt")) {
		while (true) {
			char[] buffer = new char[2023];
			int n = reader.read(buffer);
			if (n == -1) break;;//文件读取完毕了
			String str = new String(buffer, 0, n);//buffer数组的0-n构造成string
			System.out.printf(str);
		}
	}
}

char占2字节，但是你好这种中文，每个字符是3个字节的utf8，但是此处读取来的每个字符咋就成2个字节了呢?
这是因为此处这个代码，相当于是当前文件中的utt8在按照字符读取的的候，先转成unicode。每个char里存储的是对应的unicode的值.如果基于unicode最终还可以构造回utf8的String.

5.2 使用Writer字符流写文件（普通写和追加写）

1. 普通写

public static void main(String[] args) throws IOException {
	try (Writer writer = new FileWriter("./test.txt")) {
		String str = "普通写入文件(字符串)";
		writer.write(str);
	}
}

2. 追加写

public static void main(String[] args) throws IOException {
	try (Writer writer = new FileWriter("./test.txt", true)) {
		String str = "追加写入文件(字符串)";
		writer.write(str);
	}
}

6. 利用 Scanner 进行字符读取

上述例子中使用的方法是对字符类型直接使用 InputStream 进行读取是非常麻烦且困难的。所以，其实还可以使用一种之前比较熟悉的类来完成该工作，就是 Scanner 类。Scanner(System.in)本质上就是一个InputStream。

构造方法	说明
Scanner(InputStream is, String charset)	使用 charset 字符集进行 is 的扫描读取

6.1 示例一

public static void main(String[] args) throws  IOException {
	try(InputStream inputStream = new FileInputStream("./test.txt")) {
		Scanner scanner = new Scanner(inputStream);
		while (scanner.hasNext()) {
			String str = scanner.next();
			System.out.println(str);
		}
	}
}

7. 利用 PrintWriter 找到我们熟悉的方法

上述，其实已经完成输出工作，但总是有所不方便，接来下将 OutputStream 处理下，使用PrintWriter 类来完成输出，因为PrintWriter 类中提供了 print/println/printf 方法。

public static void main(String[] args) throws IOException {
	try (OutputStream os = new FileOutputStream("./test.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();
			}
		}
	}
}

六 .练习

示例 1 查找硬盘上的文件位置

给定一个文件名，去指定的目录中进行搜索。找到文件名匹配的结果，并打印出完整的路径.

文件系统的目录结构是"树形”结构，既然是搜索，就会涉及到遍历。针对树的遍历，一般都是要借助递归的，此处的递归要比二叉树更复杂一点。目录中有几个子目录，就递归几次.

public static void main(String[] args) {
	//1.第一步：输入信息
	Scanner scanner = new Scanner(System.in);
	System.out.println("请输入要搜索的文件名：");
	String fileName = scanner.next();
	System.out.println("请输入要搜索的文件名：");
	String rootPath = scanner.next();
	File rootfile = new File(rootPath);
	if (!rootfile.isDirectory()) {//不是目录
		System.out.println("输入的路径有误！");
		return;
	}
	//2.第二步，根据要搜索的路径，按照递归的方式搜索文件
	fileSearch(rootfile, fileName);
}
private static void fileSearch(File rootfile, String fileName) {
	//1.把当前目录的文件和子目录全部列出
	File[] files = rootfile.listFiles();
	if (files == null) {
		return;//空目录，直接返回
	}
	//2.遍历上面列出的files，判断每一个文件时目录还是文件
	for (File file : files) {
		System.out.println("当前遍历到了：" + file.getAbsolutePath());
		if (file.isFile()) {//是普通文件，判断文件名是否是要查找的文件
			if (fileName.equals(file.getName())) {
				System.out.println("找到了要查找的文件！" + file.getAbsolutePath());
				exit(Integer.parseInt("-1"));
			}
		}
		else {//是目录，要进行递归
			fileSearch(file, fileName);
		}
	}
}

进行递归，就是要进行树的遍历，把目录中和其中的子目录中的所有的文件都遍历一遍来查找是否有符合要求的文件。这里只能叫做"遍历”谈不上先序中序后序。因为此处是N叉树。并且每个节点上也有很多文件。

示例 2 文件复制

把一个文件复制一下，成为另一个文件，把第一个文件读方式打开，依次读取出这里的每个字节，再把读到的内容，写入到另一个文件里。

public static void main(String[] args) {
	Scanner scanner = new Scanner(System.in);
	System.out.println("请输入要复制的源文件：");
	String srcPath = scanner.next();
	System.out.println("请输入要复制到的目的文件：");
	String destPath = scanner.next();

	//合法性判定
	//1. 判断要复制的原文件是否存在
	File srcFile = new File(srcPath);
	if (!srcFile.isFile()) {//要复制的原文件不存在，或者不是文件
		System.out.println("源文件路径有误!");
		return;
	}
	//1. 判断要复制到的目的文件的目录是否存在
	File destFile = new File(destPath);
	if (!destFile.getParentFile().isDirectory()) {//复制到的目的文件的目录不存在，或者不是文件
		System.out.println("目的文件路径有误!");
		return;
	}

	//复制操作：
	try (InputStream inputStream = new FileInputStream(srcFile);//使用这个语法来编写代码的时候，可以让（）里写多个对象定义的多个之间使用；来分割开
	OutputStream outputStream = new FileOutputStream(destFile)) {//此处每个对象都会在ty结束之后执行close
		while (true) {
			byte[] buffer = new  byte[1024];
			int n = inputStream.read(buffer);
			if (n == -1) break;//读取完毕
			outputStream.write(buffer, 0, n);
		}
	}
	catch (IOException e) {
		throw new RuntimeException(e);
	}
}

上述是按照二进制的方式来复制的，可以复制任何文件，不仅仅是文本文件

示例 3 按照文件内容搜索

第三个例子，还是在目录中搜索，按照文件内容的方式搜索。用户输入一个目录，一个要搜索的词。遍历文件的过程中，如果文件包含了要搜索的词此时就把文件的路径打印出来。这个匹配过程，就需要把文件内容读取出来，再在文件内容中进行查找。

public static void main(String[] args) throws IOException {
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入要搜索的路径：");
    String rootPath = scanner.next();
    System.out.println("请输入要查询的词语：");
    String word = scanner.next();
    //合法性判定
    //1. 判断要复制的原文件是否存在
    File rootFile = new File(rootPath);
    if (!rootFile.isDirectory()) {//要复制的原文件不存在，或者不是文件
        System.out.println("输入的要搜索的路径有误!");
        return;
    }
    WordSearch(rootFile, word);
}

private static void WordSearch(File rootFile, String word) throws IOException {
    //1.把当前目录的文件和子目录全部列出
    File[] files = rootFile.listFiles();
    if (files == null) {
        return;//空目录，直接返回
    }
    //2.遍历上面列出的files，判断每一个文件时目录还是文件
    for (File file : files) {
        System.out.println("当前遍历到了：" + file.getAbsolutePath());
        if (file.isFile()) {//是普通文件，判断文件名是否是要查找的文件
                //在文件内容中搜索
            searchInFile(file, word);
        }
        else {//是目录，要进行递归
            WordSearch(file, word);
        }
    }
}

private static void searchInFile(File file, String word) throws IOException {
    //1.备案文件内容读出来
    try (InputStream inputStream = new FileInputStream(file)) {
        StringBuilder stringBulider = new StringBuilder();
        while (true) {
            byte[] buffer = new byte[1024];
            int n = inputStream.read(buffer);
            if (n == -1)  break;
            //取出文件的一部分，需要把文件内容整体拼接在一起
            String str = new String(buffer, 0, n);
            stringBulider.append(str);
        }
        System.out.println("[文件内容]：" + stringBulider);
        //循环结束，文件读取完毕，此时stringBulider中就是包含整个文件的字符串了
        if (stringBulider.indexOf(word) == -1) {//没有找到，直接返回
            return;
        }
        //找到了，打印文件的路径
        System.out.println("找到了！" + word + "在" + file.getAbsolutePath() + "中。");
    }
}

上述代码中，基于indexOf这样的方式进行文件内容的匹配，执行速度其实是非常慢的