目录
-
- Java中操作文件
-
- File概述
- [文件内容的读写------文件流 stream](#文件内容的读写——文件流 stream)
-
- InputStream
- FileInputStream概述
- [利用 Scanner 进行字符读取](#利用 Scanner 进行字符读取)
- [OutputStream 概述](#OutputStream 概述)
- 练习
Java中操作文件
Java 中通过 java.io.File
类来对一个文件(包括目录)进行抽象的描述。注意,有 File 对象,并不代表真实存在该文件。
文件系统操作
创建文件、删除文件、创建目录
通过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() | 判断用户是否对文件有可写权限 |
观察 get 系列的特点和差异
java
//File的使用
public class Demo1 {
public static void main(String[] args) throws IOException {
File file=new File("./test.txt");
System.out.println(file.getParent());
System.out.println(file.getName());
System.out.println(file.getPath());
System.out.println(file.getAbsolutePath());
System.out.println(file.getCanonicalFile());
}
}
//运行结果
.
test.txt
.\test.txt
C:\Users\幽琴健\java_Code\giteedemo\system_code\.\test.txt
C:\Users\幽琴健\java_Code\giteedemo\system_code\test.txt
普通文件的创建
java
public class Demo2 {
public static void main(String[] args) throws IOException {
File file=new File("./test.txt");
//创建文件
file.createNewFile();
System.out.println(file.exists());
System.out.println(file.isFile());
System.out.println(file.isDirectory());
}
}
//运行结果
true
true
false
普通文件的删除
java
//文件删除
public class Demo3 {
public static void main(String[] args) throws InterruptedException, IOException {
File file =new File("./test.txt");
System.out.println(file.createNewFile());
//System.out.println(file.delete());
//是等到程序退出了再删除,不是立即删除;
file.deleteOnExit();
System.out.println(file.exists());
Thread.sleep(5000);
}
}
//运行结果
true
true
观察目录的创建1
java
public class Demo4 {
public static void main(String[] args) {
File file=new File("./testDir");// 要求该目录不存在,才能看到相同的现象
System.out.println(file.mkdir());
System.out.println(file.isDirectory());
}
}
//运行结果
true
true
观察目录的创建2
java
public class Demo4 {
public static void main(String[] args) {
File file=new File("./testDir/111/222/333");// 要求该目录不存在,才能看到相同的现象
System.out.println(file.mkdirs());
System.out.println(file.isDirectory());
}
}
//运行结果
true
true
观察文件重命名
java
//文件重命名
public class Demo5 {
public static void main(String[] args) {
File file=new File("./test.txt");
File file2=new File("./test1.txt");
System.out.println(file.renameTo(file2));
}
}
//运行结果
true
以上文件系统的操作,都是基于File类来完成的。另外还需要文件内容的操作
文件内容的读写------文件流 stream
文件这里的内容本质是来自于硬盘,硬盘又是操作系统管理的。使用某个编程语言操作文件,本质上都是需要调用系统的api
文件内容的操作核心步骤有四个:
- 打开文件 fopen
- 关闭文件 fclose
- 读文件 fread
- 写文件 fwrite
字节流:InputStream、OutputStream,是操作字节为单位(二进制文件)
字符流:Reader、Writer,是操作字符为单位(文本文件)
Java lO 流是一个比较庞大的体系,涉及到非常多的类。这些不同类,都有各自不同的特性但是总的来说,使用方法都是类似的。
- 构造方法,打开文件
- close方法,关闭文件。(可以通过finally或者**try()**的方式去关闭,后者更优雅)
- 如果衍生自InputStream或者Reader就可以使用read方法来读数据
- 如果衍生自OutputStream或者Writer就可以使用write方法来写数据
注意:close()方法这个释放必要的资源这个操作非常重要。让一个进程打开一个文件是要从系统这里申请一定的资源的(占用进程的PCB里的文件描述符表中的一个表项,这个表是个顺序表,长度有限且不会扩容),如果不释放就会出现"文件资源泄露",如果一直打开,文件描述符表就会被占满,后续就无法继续打开新的文件了
文本文件也可以用字节流打开,只不过此时你读到的每个字节就不是完整的字符了
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
FileInputStream概述
构造方法
签名 | 说明 |
---|---|
FileInputStream(File file) | 利用 File 构造文件输入流 |
FileInputStream(String name) | 利用文件路径构造文件输入流 |
java
//Reader使用
public class Demo6 {
public static void main(String[] args) throws IOException {
// FileReader 构造方法, 可以填写一个文件路径(绝对路径/相对路径都行), 也可以填写一个构造好的 File 对象
// Reader reader = new FileReader("d:/test.txt");
// try {
// // 中间的代码无论出现啥情况, close 都能保证执行到.
// } finally {
// // 抛出异常, 或者 return, close 就都执行不到了~~
// reader.close();
// }
// 上述使用 finally 的方式能解决问题, 但是不优雅.
// 使用 try with resources 是更好的解决方案.
try(Reader reader=new FileReader("d:/test.txt")){
while(true){
char[] buf=new char[1024];
int n=reader.read(buf);
if(n==-1){
//读到文件末尾了
break;
}
for(int i=0;i<n;i++){
System.out.print(buf[i]+" ");
}
}
}
}
}
java
public class Demo7 {
public static void main(String[] args) throws IOException {
try (InputStream inputStream = new FileInputStream("d:/test.txt")) {
while (true) {
byte[] buf = new byte[1024];
int n = inputStream.read(buf);
if (n == -1) {
break;
}
for (int i = 0; i < n; i++) {
System.out.printf("%x ", buf[i]);
}
String s = new String(buf, 0, n, "utf8");
System.out.println(s);
}
}
}
}
利用 Scanner 进行字符读取
上述例子中,我们看到了对字符类型直接使用 InputStream 进行读取是非常麻烦且困难的,所以,我们使用一种我们之前比较熟悉的类来完成该工作,就是 Scanner 类。
构造方法 | 说明 |
---|---|
Scanner(InputStream is, String charset) | 使用 charset 字符集进行 is 的扫描读取 |
java
public class Demo8 {
public static void main(String[] args) throws IOException {
try(InputStream inputStream=new FileInputStream("d:/test.txt")){
Scanner scanner=new Scanner(inputStream);
//此时就是从test.txt这个文件中读取数据了
String s=scanner.next();
System.out.println(s);
}
}
}
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
java
public class Demo9_1 {
public static void main(String[] args) throws IOException {
try(OutputStream outputStream=new FileOutputStream("d:/test.txt")){
outputStream.write('H');
outputStream.write('e');
outputStream.write('l');
outputStream.write('l');
outputStream.write('o');
//不要忘记了 flsuh()
outputStream.flush();
}
}
}
练习
扫描指定目录,并找到名称中包含指定字符的所有普通文件(不包含目录),并且后续询问用户是否要删除该文件
java
public class Demo10 {
private static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
//1、让用户输入一个目录,后续的查找都是针对这个目录来进行的
System.out.println("请输入要搜索的根目录:");
File rootPath = new File(scanner.next());
//2、再让用户输入要搜索/要删除的关键词
System.out.println("请输入要删除的关键词:");
String word = scanner.next();
//3、判定一下当前要输入的目录是否有效
if (!rootPath.isDirectory()) {
System.out.println("您输入的路径不是合法目录");
return;
}
//4、遍历目录,从根目录出发,按照深度优先(递归)的方式进行遍历
scanDir(rootPath,word);
}
public static void scanDir(File curDir, String word) {
//1、先列出当前目录中都包含哪些内容
File[] files = curDir.listFiles();
if (files == null || files.length == 0) {
//非法目录或者空目录
return;
}
//2、遍历列出的文件,分两种情况讨论
for (File f : files) {
//加个日志,方便查看程序执行的过程
System.out.println(f.getAbsolutePath());
if (f.isFile()) {
//3、如果当前文件是普通文件,看看文件名是否包含了word,来决定是否要删除
dealFile(f, word);
} else {
//4、如果当前文件是目录文件,就递归执行scanDir
scanDir(f, word);
}
}
}
private static void dealFile(File f, String word) {
//1、先判定当前文件名是否包含word
if (!f.getName().contains(word)) {
//此时这个文件不包含word关键词,直接跳过
return;
}
//2、包含word就需要询问用户是否需要删除该文件?
System.out.println("该文件是:" + f.getAbsolutePath() + ",是否确认删除(Y/N)");
String choice = scanner.next();
if (choice.equals("Y") || choice.equals("y")) {
f.delete();
}
//如果是其他值就忽略
}
}
//运行结果
请输入要搜索的根目录:
d:/tmp
请输入要删除的关键词:
test
d:\tmp\111
d:\tmp\111\aaa
d:\tmp\111\aaa\test.txt
该文件是:d:\tmp\111\aaa\test.txt,是否确认删除(Y/N)
n
d:\tmp\222
d:\tmp\222\bbb
d:\tmp\222\bbb\新建 文本文档.txt
d:\tmp\333
d:\tmp\333\ccc
进行普通文件的复制
java
public class Demo11 {
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
//1、输入路径并且合法性判定
System.out.println("请输入要复制的源文件路径:");
String src = scanner.next();
File srcFile = new File(src);
if (!srcFile.isFile()) {
System.out.println("您输入的源文件路径非法");
return;
}
System.out.println("请输入要复制到的目标路径:");
String dest = scanner.next();
File destFile = new File(dest);
//不要求目标文件本身存在. 但是得保证目标文件所在的目录, 得是存在的.
//假设目标文件写作 d:/tmp/cat2.jpg, 就需要保证 d:/tmp 目录是存在的.
if (!destFile.getParentFile().isDirectory()) {
System.out.println("您输入的目标路径非法");
return;
}
//2、进行复制操作的过程,按照字节流打开
try (InputStream inputStream = new FileInputStream(srcFile);
OutputStream outputStream = new FileOutputStream(destFile)) {
while (true) {
byte[] buffer = new byte[20480];
int n = inputStream.read(buffer);
System.out.println("n=" + n);
if (n == -1) {
System.out.println("读取到EOF,循环结束");
break;
}
outputStream.write(buffer, 0, n);
}
}
}
}
//运行结果
请输入要复制的源文件路径:
d:/tmp/111/calculator.png
请输入要复制到的目标路径:
d:/tmp/222/calculator2.png
n=20480
n=220
n=-1
读取到EOF,循环结束
扫描指定目录,并找到名称或者内容中包含指定字符的所有普通文件(不包含目录)
java
public class Demo12 {
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要扫描的根目录:");
String rootPath = scanner.next();
File rootDir = new File(rootPath);
if (!rootDir.isDirectory()) {
System.out.println("您输入的根目录不是非法目录");
return;
}
System.out.println("请输入要找出的文件名中的字符");
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.getCanonicalFile());
}
}
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 inputStream = new FileInputStream(file)) {
try (Scanner scanner = new Scanner(inputStream, "UTF-8")) {
while (scanner.hasNextLine()) {
sb.append(scanner.nextLine());
sb.append("\r\n");
}
}
}
return sb.indexOf(token) != -1;
}
}
//运行结果
请输入要扫描的根目录:
d:/tmp
请输入要找出的文件名中的字符
hello
共找到了符合条件的文件 3 个,它们分别是:
D:\tmp\111\aaa\test.txt
D:\tmp\222\bbb\新建 文本文档.txt
D:\tmp\333\ccc\新建 文本文档.txt