文件路径
绝对路径
以盘符开头: D:\火狐浏览器\图片\wallhaven-g7dod3.jpg
相对路径
以 . 或者 … 开头的 其中 . 表示当前路径 / … 表示当前路径的父目录(上级路径)谈到相对路径,必须现有一个基准目录,相对路径就是从基准目录出发,按照一个啥样的路径找到对应文件
例如:D:\火狐浏览器\图片为基准目录
找到wallhaven-g7dod3.jpg
就是./wallhaven-g7dod3.jpg 这就是表示当前目录(基准目录)
还是以D:\火狐浏览器\图片为基准目录
找到uTools-2.5.2.exe 就是 …/uTools-2.5.2.exe(两个点)
这个就表示基准目录的上一级路径D:\火狐浏览器,从这个路径找到uTools-2.5.2.exe这个文件
即便是定位到同一个文件,如果基准目录不同,此时相对路径也不同
java中操作文件
import java.io.File;
import java.io.IOException;
// File 的构造
public class Demo1 {
public static void main(String[] args) throws IOException {
File f = new File("d:\\text.txt");
System.out.println(f.getParent()); // 获取到文件的父目录
System.out.println(f.getName()); // 获取到文件名
System.out.println(f.getPath()); // 获取到文件路径(构造 File 的时候指定的路径)
System.out.println(f.getAbsolutePath()); // 获取到绝对路径
System.out.println(f.getCanonicalPath()); // 获取到绝对路径
System.out.println("=================");
File f2 = new File("./test.txt");
System.out.println(f2.getParent()); // 获取到文件的父目录
System.out.println(f2.getName()); // 获取到文件名
System.out.println(f2.getPath()); // 获取到文件路径(构造 File 的时候指定的路径)
System.out.println(f2.getAbsolutePath()); // 获取到绝对路径
System.out.println(f2.getCanonicalPath()); // 获取到绝对路径
}
}
普通文件的创建和删除
import java.io.File;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
File file = new File("./test.txt");
System.out.println("创建前:");
System.out.println("文件是否真实存在: "+file.exists());
System.out.println("文件是否是一个目录: "+file.isDirectory());
System.out.println("文件是否是一个普通文件: "+file.isFile());
System.out.println("创建后:");
System.out.println("文件创建是否成功: "+file.createNewFile());
System.out.println("文件是否真实存在: "+file.exists());
System.out.println("文件是否是一个目录: "+file.isDirectory());
System.out.println("文件是否是一个普通文件: "+file.isFile());
System.out.println("再次创建:");
System.out.println("文件创建是否成功: "+file.createNewFile());
}
}
deleteOnExit 的使用
import java.io.File;
import java.io.IOException;
public class Test1 {
public static void main(String[] args) throws IOException, InterruptedException {
File file = new File("./test.txt");
System.out.println(file.exists());
System.out.println(file.createNewFile());
System.out.println(file.exists());
Thread.sleep(3000);
file.deleteOnExit();
System.out.println(file.exists());
}
}
单级目录的创建
import java.io.File;
public class FileDemo4 {
public static void main(String[] args) {
File file = new File("test");
System.out.println(file.isDirectory());
System.out.println(file.isFile());
System.out.println(file.mkdir());
System.out.println(file.isDirectory());
System.out.println(file.isFile());
}
}
多级目录的创建
import java.io.File;
public class Test2 {
public static void main(String[] args) {
File file = new File("aaa/bbb/ccc");
System.out.println(file.isDirectory());
System.out.println(file.isFile());
System.out.println(file.mkdirs());
System.out.println(file.isDirectory());
System.out.println(file.isFile());
}
}
文件的重命名
import java.io.File;
import java.io.IOException;
public class Test2 {
public static void main(String[] args) throws IOException {
File file1 = new File("./test.txt");
File file2 = new File("./test2.txt");
System.out.println(file1.exists());
System.out.println(file1.createNewFile());
System.out.println(file1.exists());
System.out.println(file1.renameTo(file2));
}
}
文件的移动
import java.io.File;
public class Test2 {
public static void main(String[] args) {
File file1 = new File("./test2.txt");
File file2 = new File("./aaa/test2.txt");
file1.renameTo(file2);
}
}
打印当前目录下所有的文件名
import java.io.File;
import java.util.Arrays;
public class Test2 {
public static void main(String[] args) {
File file = new File(".");
String[] files = file.list();
System.out.println(Arrays.toString(files));
}
}
文件内容的读写 – 数据流
FileInputStream
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class Demo8 {
public static void main(String[] args) {
// 构造方法中需要指定打开文件的路径.
// 此处的路径可以是绝对路径, 也可以是相对路径, 还可以是 File 对象
// InputStream inputStream = null;
// try {
// // 1. 创建对象, 同时也是在打开文件.
// inputStream = new FileInputStream("d:/test.txt");
// // 2. 尝试一个一个字节的读, 把整个文件都读完.
// while (true) {
// int b = inputStream.read();
// if (b == -1) {
// // 读到了文件末尾
// break;
// }
// System.out.println(b);
// }
// } catch (IOException e) {
// e.printStackTrace();
// } finally {
// // 3. 读完之后要记得关闭文件, 释放资源~
// try {
// inputStream.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
// try (InputStream inputStream = new FileInputStream("d:/test.txt")) {
// while (true) {
// int b = inputStream.read();
// if (b == -1) {
// break;
// }
// System.out.println(b);
// }
// } catch (IOException e) {
// e.printStackTrace();
// }
try (InputStream inputStream = new FileInputStream("d:/hello.txt")) {
// 一次读取若干个字节.
while (true) {
byte[] buffer = new byte[1024];
int len = inputStream.read(buffer);
if (len == -1) {
// 如果返回 -1 说明读取完毕了
break;
}
for (int i = 0; i < len; i++) {
System.out.println(buffer[i]);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
FileOutputStream
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
// 使用字节流, 写文件的案例.
public class Demo9 {
public static void main(String[] args) {
try (OutputStream outputStream = new FileOutputStream("d:/text.txt")) {
// outputStream.write(97);
// outputStream.write(98);
// outputStream.write(99);
byte[] buffer = new byte[]{
97, 98, 99};
outputStream.write(buffer);
} catch (IOException e) {
e.printStackTrace();
}
}
}
FileReader
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
// 按照字符来读写
public class Demo10 {
public static void main(String[] args) {
try (Reader reader = new FileReader("d:/test.txt")) {
// 按照字符来读.
while (true) {
char[] buffer = new char[1024];
int len = reader.read(buffer);
if (len == -1) {
break;
}
// for (int i = 0; i < len; i++) {
// System.out.println(buffer[i]);
// }
// 如果这里传入的 数组 是 byte 数组, 还可以手动的指定一下 utf8 字符集避免乱码.
String s = new String(buffer, 0, len);
System.out.println(s);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
FileWriter
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("d:/text.txt")) {
writer.write("xyz");
} catch (IOException e) {
e.printStackTrace();
}
}
}
案例一
== 扫描一个指定的目录,并找到名称中包含指定字符的所有普通文件,并且根据用户的选择来判断是否要删除文件.==
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
// 案例1, 实现查找文件并删除
public class Demo12 {
public static void main(String[] args) {
// 1. 先输入要扫描的目录, 以及要删除的文件名
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要扫描的路径: ");
String rootDirPath = scanner.next();
System.out.println("请输入要删除的文件名: ");
String toDeleteName = scanner.next();
File rootDir = new File(rootDirPath);
if (!rootDir.isDirectory()) {
System.out.println("输入的扫描路径有误!");
return;
}
// 2. 遍历目录, 把 指定目录 中的所有文件和子目录都遍历一遍, 从而找到要删除的文件
// 通过这个方法来实现递归遍历并删除的操作
scanDir(rootDir, toDeleteName);
}
private static void scanDir(File rootDir, String toDeleteName) {
// 1. 先列出 rootDir 中都有哪些内容
File[] files = rootDir.listFiles();
if (files == null) {
// rootDir 是一个空目录
return;
}
// 2. 遍历当前列出的这些内容. 如果是普通文件, 就检测文件名是否是要删除的文件.
// 如果是目录, 就递归的进行遍历
for (File f : files) {
if (f.isFile()) {
// 普通文件的情况
if (f.getName().contains(toDeleteName)) {
// 不要求名字完全一样, 只要文件名中包含了关键字即可删除
// 就进行删除操作
deleteFile(f);
}
} else if (f.isDirectory()) {
// 目录就递归的进行遍历
scanDir(f, toDeleteName);
}
}
}
private static void deleteFile(File f) {
try {
System.out.println(f.getCanonicalPath() + " 确认要删除吗? (Y/n)");
Scanner scanner = new Scanner(System.in);
String choice = scanner.next();
if (choice.equals("Y") || choice.equals("y")) {
f.delete();
System.out.println("文件删除成功!");
} else {
System.out.println("文件取消删除!");
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
案例二
进行普通文件的复制
import java.io.*;
import java.util.Scanner;
public class Demo13 {
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 srcFile = new File(src);
if (!srcFile.isFile()) {
System.out.println("输入的源路径不正确!");
return;
}
// 此处不太需要检查目标文件是否存在. OutputStream 写文件的时候能够自动创建不存在的文件.// 2. 读取源文件, 拷贝到目标文件中try (InputStream inputStream = new FileInputStream(src)) {
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();
}
}
}
案例三
扫描指定目录，并找到名称或者内容中包含指定字符的所有普通文件（不包含目录）
import java.io.*;
import java.util.Scanner;
public class Demo14 {
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;
}
// 2. 递归的进行遍历
scanDir(rootDir, word);
}
private static void scanDir(File rootDir, String word) throws IOException {
// 1. 先列出 rootDir 中都有哪些内容File[] files = rootDir.listFiles();
if (files == null) {
return;
}
// 2. 遍历每个元素, 针对普通文件和目录分别进行处理.for (File f : files) {
if (f.isFile()) {
// 针对文件进行内容查找if (containsWord(f, word)) {
System.out.println(f.getCanonicalPath());
}
} else if (f.isDirectory()) {
// 针对目录进行递归
scanDir(f, word);
}
}
}
private static boolean containsWord(File f, String word) {
// 写代码, 慎重使用缩写!!! 缩写的可读性会比较差. (一些业界常见缩写, 可以用, 不要随便滥用)
StringBuilder stringBuilder = new StringBuilder();
// 把 f 中的内容都读出来, 放到一个 StringBuilder 中try (Reader reader = new FileReader(f)) {
char[] buffer = new char[1024];
while (true) {
int len = reader.read(buffer);
if (len == -1) {
break;
}
// 把这一段读到的结果, 放到 StringBuilder 中
stringBuilder.append(buffer, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}
// indexOf 返回的是子串的下标. 如果 word 在 stringBuilder 中不存在, 则返回下标为 -1return stringBuilder.indexOf(word) != -1;
}
}
