一、认识文件
我们先来认识狭义上的文件(file)。针对硬盘这种持久化存储的I/O设备，当我们想要进行数据保存时，往往不是保存成一个整体，而是独立成一个个的单位进行保存，这个独立的单位就被抽象成文件的概念，就类似办公桌上的一份份真实的文件一般。
文件除了有数据内容之外，还有一部分信息，例如文件名、文件类型、文件大小等并不作为文件的数据
而存在，我们把这部分信息可以视为文件的元信息
平时说的文件一般都是指存储在硬盘上的普通文件。
形如：txt文本、jpg图片、mp4视频、rar压缩包等这些文件都可以认为是普通文件。
它们都是在硬盘上存储的。
但是站在计算机专业术语的角度上来讲：
在计算机中文件可能是一个广义的概念，就不只是包含普通文件，还可以包含目录（把目录称为目录文件），目录俗称文件夹。
在操作系统中，还会使用文件来描述一些其它的硬件设备或者软件资源。
其实站在操作系统的角度上来看，所谓的文件，其实是一个非常广义的概念。
不仅仅指的是我们日常生活中所说的这些普通文件，也包含目录，还包含一些软硬件资源设备。
后面讲网络编程的时候，会讲到一个很重要的设备“网卡”。
网卡，是一个硬件设备。但是在操作系统中就把 网卡 这样的硬件设备也给抽象成了一个文件。
这样的操作，会给我们进行网络编程带来很大便利。
我们要想通过网卡来收数据，直接按照 读文件代码 去写 就可以了。
想通过网卡来发数据，那就按照 写文件代码 去写就行了
这样做带来的好处：简化开发。
通过这种文件的操作，来完成操作网卡的过程。
除此之外，还有显示器，键盘，这都是硬件设备吧。
操作系统也是把这些设备视为文件。
想从键盘读取数据，其实也是通过类似读文件的方式来进行的。
想往显示器上写一个数据，也是通过类似写文件的方式来进行的。
因此，操作系统谈到的文件，其实是一个更加广泛的概念。它会涉及到各个方面的情况。
当前我们需要讨论的文件，主要还是针对普通文件来讨论的。
后面去学习一些其他的硬件设备对应的文件，其实也是通过类似的代码来实现操作。
因此，我们虽然讨论的是针对普通文件为例来去演示，但实际上这里的一些代码，和后需用到的一些代码，尤其是网络编程的代码，是非常具有共性的。
二、普通文件 与 机械硬盘
普通文件是保存在硬盘上的。【一般讨论的都是机械硬盘】
机械硬盘一旦通电，里面的盘片就会高速运转，
例如：我们使用的是 7200转/分钟 的家用机械硬盘，那么，每秒就是 120转/秒。
磁头就会在盘片上找到对应的数据。
因为盘片上是有一圈圈 磁道的。
然后呢，我们就把数据 去按照这一圈一圈的方式来往上去写。
因为这里面的盘片，其实是一个非常精密的设备。
这里面是可以存储很多数据的。
像这么小的硬盘（大概只有现在手机的一半大小），就可以存储上T的数据。
但是 存储空间的大小，受限于机械硬盘的硬件结构。
盘片转速越高，读写速度也就越快。
但是因为工艺的限制，盘片的转速也不可能无限高。
（现在最好的机械硬盘大概是每分钟 1 万 多 转）
另外，机械硬盘的读写速度，已经有10年 停滞不前了。【技术上无法精进】
现在的机械硬盘都是往大容量的方向发展。
前面的博文也说到过，内存的读写速度 比 现在的硬盘读写速度 快很多！！！
快 3-4 个数量级，大概是上万倍。
后面为了解决这个问题，就有了固态硬盘（SSD）。
固态硬盘的硬件结构 和 机械硬盘 截然不同。
固态硬盘就是一个大号的U盘。
U盘：里面可以存储数据，但是又不需要盘片这些东西。主要是 flash 芯片（闪存），通过这个东西来进行存储数据，而且能获取到更高速率的读写。
所以，固态硬盘的读写速度要比机械硬盘高很多。【高好几倍】
现在最好的固态硬盘，读写速度已经接近十几年前的内存水平了。
本篇博文主要讨论的是 以机械硬盘为主。 因为当前企业中使用的服务器还是以机械硬盘为主。
因为 SSD 的成本 是 机械硬盘的好几倍。（4-5倍）
三、文件的分类
站在程序员的角度，主要把文件分成两类：
1、文本文件：里面存储的是字符
2、二进制文件：里面存储的是字节
针对这两种文件，在编程的时候会存在差异。
3.1、如何判断是文本文件还是二进制文件
我们判定一个文件是文本 ，还是 二进制文件，有一个简单直接的方法。
就是 把一个文件直接用记事本打开，如果是乱码就是 二进制文件，如果不是乱码就是文本。
四、文件的目录结构
随着文件越来越多，对文件的系统管理也被提上了日程，如何进行文件的组织呢，一种合乎自然的想法出现了，就是按照层级结构进行组织 —— 也就是我们数据结构中学习过的树形结构。这样，一种专门用来存放管理信息的特殊文件诞生了，也就是我们平时所谓文件夹(folder)或者目录(directory)的概念
也就是说普通文件，一定是树的叶子结点。
目录文件，就可以看作是一个子树，也就是非叶子节点。
五、文件路径（Path）
在操作系统中，就通过“路径” 这样的概念，来描述一个具体 文件/目录 的位置。
5.1、绝对路径
以盘符开头的。【以 C、D、E、F等等，盘名开头的】
5.2、相对路径
以 . 或者 … 开头的文件路径。
其中 . 表示当前路径， … 表示当前路径的父目录（上级路径）。
谈到相对路径，必须要有一个基准目录。
对于路径就是从基准目录出发，按照一个什么样的路径找到的对应文件。
注意！即使是定位到同一个文件，如果基准路径不同，此时的相对路径也就不同
绝对路径 和 相对路径 的概念非常重要！！！！
虽然面试不考，但是我们在后面的编程中，需要频繁的和这些路径打交道。、
六、java 中操作文件
Java中操作文件，主要是包含两类操作
1、文件系统相关的操作
2、文件内容相关的操作
6.1、文件系统相关的操作
这个是C语言中没有的操作。C语言标准库不支持这个操作。
文件系统相关的操作：指的是通过“文件资源管理器” 能够完成的一些功能
它具有的功能
1、列出目录中有哪些文件
2、创建文件（直接右键点击菜单创建，就可以创建了）
3、创建 目录/文件夹
4、删除文件
5、重命名文件
…
这些都是文件资源管理器所能够完成的功能。
简单来说 文件资源管理器 能做什么，我们的文件系统相关操作的代码就能做什么。
在Java中提供了一个 File 类，通过这个类来完成上述操作。
首先，这个File类就描述了一个文件/目录。
基于这个对象就可以实现上面的功能。
6.2、File类中的属性
| 修饰符及类型 | 属性 | 说明 |
|---|---|---|
| static String | pathSeparator | 依赖于系统的路径分隔符，String 类型的表示 |
| static char | pathSeparator | 依赖于系统的路径分隔符，char 类型的表示 |
6.3、File类中的构造方法
| 签名 | 说明 |
|---|---|
| File(File parent, Stringchild) | 根据父目录 + 孩子文件路径，创建一个新的 File 实例 |
| File(String pathname) | 根据文件路径创建一个新的 File 实例，路径可以是绝对路径或者相对路径 |
| File(String parent, Stringchild) | 根据父目录 + 孩子文件路径，创建一个新的 File 实例，父目录用路径表示 |
File 的构造方法，能够传入一个路径，来指定一个文件。
这个路径可以是绝对路径，也可以是相对路径。
6.4、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(Filedest) | 进行文件改名，也可以视为我们平时的剪切、粘贴操作 |
| boolean | canRead() | 判断用户是否对文件有可读权限 |
| boolean | canWrite() | 判断用户是否对文件有可写权限 |
6.5、代码示例
6.5.1、File类的构造方法
通过绝对路径和相对路径来指向一个文件
6.5.2、File类的普通方法
目前上述操作，都是针对文件系统的操作。
主要还是 增删改查 的一些操作。
但是呢，这些操作只是作用于文件表面，并没有对文件的内容做出实质性的改变。
getParent、getName、getPath、getAbsolutePath、getCanonicalPath
public class Dome1 {
public static void main(String[] args) throws IOException {
File f1 = new File("D:test.txt");
System.out.println(f1.getPath());//返回 File 对象的文件路径
System.out.println(f1.getParent());//返回 File 对象的父目录文件路径
System.out.println(f1.getName());//返回 FIle 对象的纯文件名称
System.out.println(f1.getAbsolutePath());//返回 File 对象的绝对路径
System.out.println(f1.getCanonicalPath());//返回 File 对象的修饰过的绝对路径
System.out.println("--------------------------");
File f2 = new File("./test.txt");
System.out.println(f2.getPath());//返回 File 对象的文件路径
System.out.println(f2.getParent());//返回 File 对象的父目录文件路径
System.out.println(f2.getName());//返回 FIle 对象的纯文件名称
System.out.println(f2.getAbsolutePath());//返回 File 对象的绝对路径
System.out.println(f2.getCanonicalPath());//返回 File 对象的修饰过的绝对路径
}
}
exists、isDirectory、isFile
public class Dome2 {
public static void main(String[] args) {
File f1 = new File("d:/test.txt");
System.out.println(f1.exists());//判断 File 对象描述的文件是否真实存在
System.out.println(f1.isDirectory());//判断 File 对象代表的文件是否是一个目录
System.out.println(f1.isFile());//判断 File 对象代表的文件是否是一个普通文件
}
}
createNewFile
public static void main(String[] args) throws IOException {
File f1 = new File("d:/test.txt");
//根据 File 对象，自动创建一个空文件。成功创建后返回 true
System.out.println(f1.createNewFile());
}
delete
public static void main(String[] args) {
File f1 = new File("d:/test.txt");
System.out.println(f1.delete());//根据 File 对象，删除该文件。成功删除后返回 true
}
mkdir、mkdirs
public static void main(String[] args) {
//在当前项目底下创建一个 aaa 目录
File file = new File("./aaa");
System.out.println(file.isDirectory());
file.mkdir();// mkdir 方法 只能创建一级目录
System.out.println(file.isDirectory());
}
与mkdir方法，相似的方法还有一个 mkdirs 方法，
意思创建多级目录。
public static void main(String[] args) {
//在当前项目底下创建一个 aaa 目录
File file = new File("./aaa/bbb/ccc");
System.out.println(file.isDirectory());
file.mkdirs();
System.out.println(file.isDirectory());
}
目前上述操作，都是针对文件系统的操作。
主要还是 增删改查 的一些操作。
但是呢，这些操作只是作用于文件表面，并没有对文件的内容做出实质性的改变。
七、文件内容相关操作
1、打开文件
2、读文件
3、写文件
4、关闭文件
针对文件内容的读写，Java提供了一组类来完成上述操作
7.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
7.1.1、FileInputStream 概述
构造方法
| 签名 | 说明 |
|---|---|
| FileInputStream(File file) | 利用 File 构造文件输入流 |
| FileInputStream(String name) | 利用文件路径构造文件输入流 |
7.1.2、针对字节的读操作
FileInputStream 一个字节一个字节的读
FileInputStream 一次读取若干个字节
利用 Scanner 进行字符读取
上述例子中，我们看到了对字符类型直接使用 InputStream 进行读取是非常麻烦且困难的，所以，我
们使用一种我们之前比较熟悉的类来完成该工作，就是 Scanner 类
| 构造方法 | 说明 |
|---|---|
| Scanner(InputStream is, String charset) | 使用 charset 字符集进行 is 的扫描读取 |
// 需要先在项目目录下准备好一个 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);
}
}
}
}
}
7.2、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() | 重要：我们知道 I/O 的速度是很慢的，所以，大多的 OutputStream 为了减少设备操作的次数，在写数据的时候都会将数据先暂时写入内存的一个指定区域里，直到该区域满了或者其他指定条件时才真正将数据写入设备中，这个区域一般称为缓冲区。但造成一个结果，就是我们写的数据，很可能会遗留一部分在缓冲区中。需要在最后或者合适的位置，调用 flush（刷新）操作，将数据刷到设备中。 |
说明
OutputStream 同样只是一个抽象类，要使用还需要具体的实现类。我们现在还是只关心写入文件中，
所以使用 FileOutputStream
7.2.1、针对字节的写操作
FileOutputStream 一次写一个字节
FileOutputStream 一次写若干字节
利用 PrintWriter 找到我们熟悉的方法
上述，我们其实已经完成输出工作，但总是有所不方便，我们接来下将 OutputStream 处理下，使用
PrintWriter 类来完成输出，因为
PrintWriter 类中提供了我们熟悉的 print/println/printf 方法
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();
}
}
}
}
7.3、FileReader 针对字符的读操作
7.4、FileWriter 针对字符的写操作
八、小程序练习
8.1、扫描指定目录，并找到名称中包含指定字符的所有普通文件（不包含目录），并且后续询问用户是否要删除该文件
意思就是：
用户输入一个目录
再输入一个要删除的文件名
找到名称中包含指定字符的所有普通文件
询问用户是否要删除该文件
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.Scanner;
/**
* 扫描指定目录，并找到名称中包含指定字符的所有普通文件（不包含目录），并且后续询问用户是否要
* 删除该文件
*/
public class Dome1 {
public static void main(String[] args) {
//1、首先输入扫描的目录，以及要删除的文件
Scanner scanner = new Scanner(System.in);
System.out.println("请输入扫描的路径");
String rootDirPath = scanner.next();
System.out.println("请输入要删除的文件名");
String toDelFileName = scanner.next();
File rootDir = new File(rootDirPath);
//2、判断一下要删除的文目录是否存在
if(!rootDir.isDirectory()){
return;
}
//3、搜到这里说明当前目录是存在的
//4、写一个函数，实现删除文件
scanDir(rootDir,toDelFileName);
}
//通过这个方法实现删除文件
private static void scanDir(File rootDir, String toDelFileName) {
//1、首先列出 rootDirPath 有哪些内容
File[] files = rootDir.listFiles();
if(files == null){
// rootDir是一个空目录
return;
}
//走到这里，说明 rootDir 一个空目录，我们就要进要遍历目录，然后删除文件
for (File f : files) {
if(f.isFile()){
//普通文件的情况
if(f.getName().contains(toDelFileName)) {
//不要求文件名字一样，只要求包含了关键字的文件都要删除
deleteFile(f);
}
}else if(f.isDirectory()){
scanDir(f,toDelFileName);
}
}
}
private static void deleteFile(File f) {
try {
System.out.println("确认要删除文件吗（Y/N） + " + f.getCanonicalPath());
Scanner scanner = new Scanner(System.in);
String chioce = scanner.next();
if(chioce.equals("Y") || chioce.equals("y")){
f.delete();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
8.2、进行普通文件的复制
文件复制，其实说白了：就是将文件给拷贝一个副本。
我们需要让用户指定两个文件路径。
一个是原路径（被复制的文件）
一个是目标路径（复制之后生成的文件）
从哪里复制到哪里，从哪里来到哪来去。
我们需要描述清楚 起点 和 终点。
然后，我们就可以在这个基础上进行具体复制操作
我们要做的事很简单。
打开源路径文件，读取里面的内容，并写入到目标文件中，
/**
* 进行普通文件的复制
*/
public class Dome2 {
public static void main(String[] args) {
//1、首先输入两个路径
Scanner scanner = new Scanner(System.in);
System.out.println("请输入源路径：");
String src = scanner.next();
System.out.println("请输入目标路径：");
String dest = scanner.next();
File scrFile = new File(src);
//2、判断一下输入的源路径是否存在
if(!scrFile.isFile()){
System.out.println("输入的源路径错误！");
return;
}
//此处不需要检查目标路径是否存在, OutputStream 进行写操作的时候，如果文件不存在会自动创建文件
//3、将源文件拷贝到目标路径里面
try (InputStream inputStream = new FileInputStream(scrFile)){
try (OutputStream outputStream = new FileOutputStream(dest)){
//把inputStream 中的数据读出来，写入到outputStream里面
byte[] buffer = new byte[1024];
while (true){
int len = inputStream.read(buffer);
if(len == -1){
//读取完毕
break;
}
//进行写入数据
//在写入数据的时候，不能将整个buffer进行写入，毕竟 buffer 可能只有一部分数据是有效数据
outputStream.write(buffer,0,len);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
8.3、扫描指定目录，并找到名称或者内容中包含指定字符的所有普通文件（不包含目录）
进行文件内容的查找文章来源：https://www.toymoban.com/news/detail-431097.html
1、输入一个路径
2、再输入一个要查找文件的 关键字
3、递归的遍历文件，找到看哪个文件里的内容包含了那些关键词，就把对应的文件路径打印出来。
思路和案例1一样，先递归遍历文件，针对每个文件都打开，并读取内容，再进行字符串查找即可。
文章来源地址https://www.toymoban.com/news/detail-431097.html
public class Dome3 {
public static void main(String[] args) throws IOException {
//1、首先输入要扫描的路径
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要扫描的路径：");
String rootDirPath = scanner.next();
System.out.println("请输入要查找的关键词：");
String word = scanner.next();
File rootDir = new File(rootDirPath);
if(!rootDir.isDirectory()){
System.out.println("没有输入的路径！");
return;
}
//实现一个函数，这个函数就用来删除办好关键词的文件
scanDir(rootDir,word);
}
//递归遍历这个路径的所有文件内容
private static void scanDir(File rootDir, String word) throws IOException {
//1、首先列举出所有目录
File[] files = rootDir.listFiles();
if(files == null){
//说明没有这个目录
return;
}
//2、遍历每个元素，针对目录或者文件进行操作
for (File f : files) {
if(f.isFile()){
//针对文件内容进行查找
if(contansWord(f,word)){
System.out.println(f.getCanonicalPath());
}
}else if(f.isDirectory()){
//针对目录进行递归遍历
scanDir(f,word);
}
}
}
private static boolean contansWord(File f, String word) {
//将文件的内容读出来，放到一个StringBuffer里面
StringBuffer stringBuffer = new StringBuffer();
try (Reader reader = new FileReader(f)){
char[] buffer = new char[1024];
while (true){
int len = reader.read(buffer);
if(len == -1){
break;
}
stringBuffer.append(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
}
//indexOf 返回得是子串的下标
return stringBuffer.indexOf(word) != -1;
}
}
到了这里，关于JavaEE初阶 - 文件/IO的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
