☕导航小助手☕
🍚写在前面
🍣🍣3.1 读文件
🍱🍱3.2 写文件
写在前面
这篇博客是关于 文件操作和IO 的下半篇的内容,主要介绍的是 文件内容的各种操作 ~
若想看上半篇的内容,请通过下面的传送门进行传送:
现在,接着上半篇的内容继续介绍 ......
三、文件内容的操作
关于文件读写的操作,主要分为这几大块:打开文件、关闭文件、读文件、写文件 ~
其中,读写文件 是关键操作 ~
但是,在读写文件之前,必须要打开文件;在使用完毕之后,必须要关闭文件 ~
在 Java中,关于文件读写,提供了几组相关的类(是父类,还有许多其他子类继承):
- 第一组:InputStream类、OutputStream类 ——> 字节流(以字节为单位的流,用来操作二进制文件的)
- 第二组:Reader类、Writer类 ——> 字符流(以字符为单位的流,用来操作文本文件的)
关于 "流",是计算机中一种常见的概念 ~
比如说,如果想接住 100ml的水 ~
可以一次接 100ml,一次就搞定;可以一次接 50ml,两次就搞定;可以一次接 10ml,十次就搞定 ......
类似于水流,可以随心所欲的控制 读写的数据量 ~
如:想 读/写 100字节的数据 ~
可以一次 读/写100字节,一次就搞定;可以一次 读/写50字节,两次就搞定;可以一次 读/写10字节,十次就搞定 ......
于是,我们就把这种 读/写 方式,称为 面向流的读/写方式 ~
3.1 读文件
3.1.1 使用字节流读文件
我们可以在 Idea 上输入 InputStream类,点击 Ctrl + 左键,便可以发现,InputStream 是一个抽象类,不可以直接 new,需要使用 new InputStream 子类的方式来进行实例化:
方法:
关于 InputStream类 的常用方法有下面几个:
修饰符及返回值类型 | 方法 | 说明 |
---|---|---|
int(其实返回的是 byte) | read() | 读取一个字节的数据,如果读取到文件末尾(EOF),则返回 -1 |
int | read(byte[ ] b) | 把文件中读到的内容,往 b数组中塞,b数组是"输出型参数";返回值是 读取成功的字节个数(往 b数组 塞的个数);-1表示已经读完了 |
int | read(byte[ ] b,int off,int len) | 从 b[ off ] 这个位置开始塞,最多塞 len - off 这么多个字节 ;返回值是 读取成功的字节个数(往 b数组 塞的个数);-1表示已经读完了 |
void | close() | 关闭字节流 |
需要注意的是,要在打开之后 一定记得要关闭文件!!!
—— 需要释放资源(内存、文件描述符表)
—— 如果打开文件之后,忘记关闭,造成的结果非常大的(文件资源泄露,就像是定时炸弹一样,并不是马上就泄露完,这就非常的麻烦了)~
一个进程,会使用PCB来描述(此时 只考虑单线程)~
PCB 里面有很多属性,文件描述符表 就是其中的一个属性,它可以看作是一个数组(顺序表),其中的每个元素 都对应着当前打开的文件,这个数组的下标 就称为 "文件描述符" ~
每次打开文件,都会在文件描述符表中 占据一个位置,每次关闭文件,都会释放一个位置;由于文件描述符表的长度是存在上限的,所以如果一个线进程一直在打开文件,没有释放文件,此时就会导致 后续进程在打开的时候失败!!!
代码示例:
package file;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class Demo6 {
//使用一下 InputStream类
public static void main(String[] args) throws IOException {
// 1.打开文件
//打开文件成功,就得到了 InputStream对象,
//后续针对文件的操作,都是通过 InputStream 来展开的
// (就相当于是 空调遥控器 可以操控空调,内存中的 InputStream对象 可以操控硬盘里面的 test2.txt文件)
//像 inputStream 这一类的 “遥控器”,在计算机中 我们通常称为:句柄(Handler)
InputStream inputStream = new FileInputStream("./test2.txt");
// 2.读取文件
while (true) {
int b = inputStream.read();
if(b == -1) {
//此时,文件读完了
break;
}
System.out.println(b);
}
// 3.关闭文件
//关闭文件,以释放 内存资源 和 文件描述符表
inputStream.close();
}
}
同时,我在 test2.txt 文件下输入了:hello
运行结果:
-- 当然,我们也可以采用其他的 read方法 来读取数据
-- 这里可以把 2.读取文件 的代码改成:
byte[] b = new byte[1024];
int len = inputStream.read(b);
System.out.println(len);
for (int i = 0; i < len; i++) {
System.out.println(b[i]);
}
此时,运行的结果是:
3.1.2 使用字符流读文件
需要注意的是,在上面的 test2.txt 文件中 存储的是英文状态的 "hello",但是但我们把它改成中文状态的 "你好" 时,那结果可就不一样了 ~
运行结果:
说明:
当前格式 是 utf-8 的格式编码,它的汉字一般是 三个字节一个汉字 ~
如果想要直观的获取 中文,那就需要去手动的转换(如下所示):
-- 这里可以把 2.读取文件 的代码改成:
byte[] b = new byte[1024];
int len = inputStream.read(b);
//把 0到len 这一段数据构成一个字符串,并且指定构造字符集的格式编码 —— utf-8
String s = new String(b,0,len,"utf-8");
System.out.println(s);
运行结果:
通过字节流,读取文本数据的时候,虽然可以读取到,但是要想真正还原成原始的版本,还是比较麻烦的,需要手动处理~
因此就可以使用 字符流 来解决上述问题(字符流 就相当于已经在底层 已经完成了里面的转换了)~
代码示例:
package file;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Demo7 {
//使用字符流读文件
public static void main(String[] args) throws IOException {
Reader reader = new FileReader("test2.txt");
char[] buffer = new char[1024];
int len = reader.read(buffer);
for (int i = 0; i < len; i++) {
System.out.print(buffer[i]);
}
//关闭资源
reader.close();
}
}
运行结果:
3.1.3 使用Scanner读取文件(推荐)
字符流来处理文本是比较方便的,但是 这里还有一种更为简单的方法,可以使用 Scanner 来读取文本文件 ~
Scanner scanner = new Scanner(System.in);
//以前我们使用的是这个样子的,可以从键盘上来输入数据
//其中,System.in 中的 in 就是 inputStream
//如果直接把 System.in 换成 inputStream
//需要 InputStream inputStream = new FileInputStream("文本");
//就可以去读自己写的文件
代码示例:
package file;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
public class Demo8 {
//使用 Scanner 来读取文本文件
public static void main(String[] args) throws IOException {
InputStream inputStream = new FileInputStream("test2.txt");
Scanner scanner = new Scanner(inputStream);
String s = scanner.next();
System.out.println(s);
inputStream.close();
}
}
运行结果:
需要注意的是,其实在上述代码中,涉及到了 read操作,这就会引出 IOException异常,此时代码就会无法进行,后面的 关闭文件(close ) 的操作就不会被运行 ~
所以可以使用 try ... catch ... finally ... 的操作来避免的 ~
这里就不做过多演示了 ~
但是,最后就会发现,这个看起来就很啰嗦 ~
所以,就可以改成这个样子了 :
这样的操作叫做 try with resource(有资源的 try)~
同时,这类写法 会在 try 实现结束之后,自动调用 inputStream 的 close方法(当然,并不是所有的类都可以这样放在try括号里面,要求这个类实现 Closeable接口,才可以这么做)~、
这种写法是比较推荐的写法~
3.2 写文件
字节流:OutputStream / FileOutputStream
字符流:Writer / FileWriter
以及,和 Scanner 相对的 PrintWriter 操作
OutoutStream类 的方法和上面的 InputStream类 的方法差不多,这里就不做过多介绍了,感兴趣的铁铁们可以自己去看看官方文档 ~
3.2.1 使用字节流写文件
package file;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Demo10 {
public static void main(String[] args) {
try(OutputStream outputStream = new FileOutputStream("test2.txt")) {
//写文件
outputStream.write('h');
outputStream.write('e');
outputStream.write('l');
outputStream.write('l');
outputStream.write('o');
}catch (IOException e) {
e.printStackTrace();
}
}
}
当我们运行这段代码时,再去查看 text2.txt 文档时,就会发现:
如果想写一个字符串,那么就可以这样做:
package file;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
public class Demo10 {
public static void main(String[] args) {
try(OutputStream outputStream = new FileOutputStream("test2.txt")) {
//写文件
String s = "hello java";
outputStream.write(s.getBytes());
}catch (IOException e) {
e.printStackTrace();
}
}
}
此时,运行程序后,再去看看 test2.txt 文件,就会发现:
需要注意的是,每一次 写文件 的操作都会清空原有的文件,然后再去重新写 ~
3.2.2 使用字符流写文件
package file;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class Demo11 {
public static void main(String[] args) {
try(Writer writer = new FileWriter("test2.txt")) {
writer.write("hello world");
}catch (IOException e) {
e.printStackTrace();
}
}
}
此时,运行程序之后,再次看看 test2.txt 文件,就会发现:
3.2.3 使用PrintWriter写文件
package file;
import java.io.*;
public class Demo12 {
public static void main(String[] args) {
try (OutputStream outputStream = new FileOutputStream("test2.txt")) {
//此处的 PrintWriter 的用法 和 System.out 有相似之处
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println("正在看博客的人好帅啊");
printWriter.flush();
}catch (IOException e) {
e.printStackTrace();
}
}
}
此时,程序运行结束之后,再来看看 test2.txt 文件:
四、代码案例
4.1 文件查找功能
扫描指定目录,并找到名称中包含指定字符的 所有普通文件(不包含目录),并且后续询问用户是否要删除该文件 ~
package file;
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
public class Demo13 {
// 实现一个递归遍历文件, 并询问删除.
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要扫描的路径: ");
String rootPath = scanner.next();
//输入的路径不存在
File root = new File(rootPath);
if (!root.exists()) {
System.out.println("您输入的路径不存在, 无法进行扫描!");
return;
}
System.out.println("请输入要删除的文件名(或者一部分): ");
String toDelete = scanner.next();
// 准备进行递归, 通过递归的方式, 来找到所有的文件.
// 找到所有的文件之后, 再尝试进行删除
scanDir(root, toDelete);
}
//rootDir 从哪个路径开始扫描 toDelete 要删除的文件
public static void scanDir(File rootDir, String toDelete) {
// 加上个日志, 看一下这里当前递归的过程.
try {
System.out.println(rootDir.getCanonicalPath());
} catch (IOException e) {
e.printStackTrace();
}
//列出扫描目录有哪些文件
File[] files = rootDir.listFiles();
if (files == null) {
// 空目录, 直接返回
return;
}
//遍历每一个文件
for (File f : files) {
if (f.isDirectory()) {
// 是目录, 就进行递归
scanDir(f, toDelete);
} else {
// 普通文件
tryDelete(f, toDelete);
}
}
}
public static void tryDelete(File f, String toDelete) {
// 看看当前文件名是否包含了 toDelete, 如果包含, 就删除, 否则就啥都不干
if (f.getName().contains(toDelete)) {
try {
System.out.println("是否要删除文件(Y/n): " + f.getCanonicalPath());
Scanner scanner = new Scanner(System.in);
String choice = scanner.next();
if (choice.equals("Y")) {
f.delete();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行程序之前:
运行程序:
此时,可以观察到结果:
4.2 复制普通文件
基本思路:
把文件1 复制成 文件2,就是 把文件1 里面的内容 都按照字节读取出来,写入到 文件2 中 ~
package file;
import java.io.*;
import java.util.Scanner;
public class Demo14 {
// 实现复制文件的功能
public static void main(String[] args) {
// 准备工作
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要复制的文件路径: ");
String srcPath = scanner.next();
File srcFile = new File(srcPath);
if (!srcFile.exists()) {
System.out.println("要复制的文件不存在!");
return;
}
if (!srcFile.isFile()) {
System.out.println("要复制的不是普通文件!");
return;
}
System.out.println("请输入要复制到的目标路径: ");
String destPath = scanner.next();
File destFile = new File(destPath);
if (destFile.exists()) {
System.out.println("要复制到的目标已经存在! ");
return;
}
// 进行拷贝工作
try (InputStream inputStream = new FileInputStream(srcFile)) {
try (OutputStream outputStream = new FileOutputStream(destFile)) {
byte[] buf = new byte[1024];
while (true) {
int len = inputStream.read(buf);
if (len == -1) {
// 拷贝完成
break;
}
outputStream.write(buf, 0, len);
}
}
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("复制完成!");
}
}
运行程序之前:
运行过程:
运行结果:
4.3 获取含有指定字符串的普通文件
package file;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
public class Demo15 {
// 遍历目录, 看某个输入的词是否在文件名或者文件内容中存在.
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要搜索的目录:");
String rootPath = scanner.next();
File rootFile = new File(rootPath);
if (!rootFile.exists()) {
System.out.println("要扫描的目录不存在!");
return;
}
if (!rootFile.isDirectory()) {
System.out.println("要扫描的路径不是目录!");
return;
}
System.out.println("请输入要搜索的词:");
String toFind = scanner.next();
// 递归遍历目录
scanDir(rootFile, toFind);
}
private static void scanDir(File rootFile, String toFind) throws IOException {
File[] files = rootFile.listFiles();
if (files == null) {
return;
}
for (File f : files) {
if (f.isDirectory()) {
scanDir(f, toFind);
} else {
tryFindInFile(f, toFind);
}
}
}
// 判定 toFind 是否是文件名 或者 是文件内容的一部分
private static void tryFindInFile(File f, String toFind) throws IOException {
// 是不是文件名的一部分
if (f.getName().contains(toFind)) {
System.out.println("找到文件名匹配的文件: " + f.getCanonicalPath());
return;
}
// 是不是文件内容的一部分
try (InputStream inputStream = new FileInputStream(f)) {
// 把文件内容整个的都读出来
StringBuilder stringBuilder = new StringBuilder();
Scanner scanner = new Scanner(inputStream);
while (scanner.hasNextLine()) {
stringBuilder.append(scanner.nextLine());
}
// 读取完毕
if (stringBuilder.indexOf(toFind) >= 0) {
System.out.println("找到文件内容匹配的文件: " + f.getCanonicalPath());
return;
}
}
}
}
打算查找 如下的文档,其中 6.txt 和 8.txt 有相同的内容 "aaa",其余文档均没有内容 ~
运行结果:
好了,关于 文件操作和IO 的内容就介绍到这里了,已经完美撒花啦 ~
如果感觉这一篇博客对你有帮助的话,可以一键三连走一波,非常非常感谢啦 ~