本文详细介绍了Java中的IO流操作，包括File类的使用，如获取文件信息、创建删除文件和目录，以及遍历文件夹。同时，文章探讨了哈希表的hashCode和equals方法在避免冲突和判断对象相等时的角色。此外，重点讲解了递归的概念、分类和应用场景，如计算阶乘、遍历文件系统等。通过对递归的理解，可以更好地处理复杂问题的简化和分解。
Lesson22_IO_File_递归
补：
Set
HashSet
TreeSet
Collections
*Hash强化：修改Key的hashCode方法和equals方法
正常重写hashCode和equals方法
hashCode()方法被调用
hashCode()方法被调用
hashCode()方法被调用
hashCode()方法被调用
// 正常情况发生Hash冲突的几率较小，不需要调用equals方法。只在发生哈希冲突时，才需要equals判断是否是同一个对象。如果是，就不再重复存入；如果不是同一个对象，则以链表形式存入
hashCode随机 ==> 存进去的值，找不到了
put元素时，通过hashCode间接计算得到的下标，和get时得到的下标不一致。
hashCode固定 ==> 存进去的每个值都冲突，equals多次调用
hashCode()方法被调用 // 第一个元素通过hashCode间接计算存放的下标
hashCode()方法被调用 // 第二个元素通过hashCode方法间接计算下标，结果发现该下标已经有一个元素了
equals()方法被调用
hashCode()方法被调用 // 第三个元素......
equals()方法被调用 // 与前两个元素依次比较是否相等，如果相等，就不存入；如果不相等，就存入。
equals()方法被调用
hashCode()方法被调用 // 第四个元素......
equals()方法被调用 // 与前面三个元素依次比较是否相等。
equals()方法被调用
equals()方法被调用
hashCode返回固定值，equals始终返回true ==> hash冲突时，新值存不进去
hashCode返回固定值，意味着每次存入新元素，必然发生哈希冲突；
此时调用equals方法，返回true，意味着判定这两个Key对象是相同的。
键 不变， 值 替换
Person{name='zhangsan', age=18}=David
第一个键，最后一次的值
hashCode返回固定值，equals返回false ==> HashSet集合，就算是同一个对象存入，也会生成链表
Person{name='zhangsan', age=18}
Person{name='zhangsan', age=18}
Person{name='zhangsan', age=18}
Person{name='zhangsan', age=18}
Person{name='zhangsan', age=18}
Person{name='zhangsan', age=18}
Person{name='zhangsan', age=18}
Person{name='zhangsan', age=18}
Person{name='lisi', age=19}
Person{name='wangwu', age=20}
Person{name='zhaoliu', age=28}
IO
-
Input 输入
-
Output 输出
-
以内存和硬盘为例。
- 输入：硬盘 --> 内存
- 输出：内存 --> 硬盘
- 硬盘 ---------输入(读)----------> 内存 ---------输出(写)----------> 硬盘
-
为什么要学IO呢？
-
之前的数据要么保存在数组中，要么保存在集合中。只要一断电，或者程序一结束，就什么都没有了。
-
之前的数据都是保存在内存中，内存，闪存，断电就清空了所有数据
-
硬盘：持久化存储。保存在硬盘中的文件，无论何时，只要打开电脑，都可以接着使用 Ctrl+S
-
场景：你在写Excel表格，忙了很久，电脑突然断电了，发现重启后，文件中的数据丢失了。（内存）
如果按了Ctrl+S ，会把内存中的数据保存到硬盘上。就不怕断电了。
-
所以，学了IO，就可以把数据保存在硬盘上，下次运行程序时，可以继续使用之前的所有数据
-
学了IO，还可以通过Java程序，操作电脑硬盘上的文件，比如，删除一个盘之类的
-
File
java.io.File，java把系统中的文件和文件夹封装为了一个File类，我们可以使用File对文件和文件夹进行操作，File类是一个与系统无关的类，任何系统都可以使用File进行对文件或文件夹的操作。是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。
-
表示硬盘上的文件或文件夹
-
通过它，可以获取硬盘上文件的一些信息
-
File静态变量
-
pathSeparator：与系统相关的路径分隔符，为方便起见，表示为字符串，Windows中为封号“；”，Linux中为冒号“：”
-
pathSeparatorChar：与系统先关的路径分隔符。
-
separator：与系统相关的默认名称，即文件名称分隔符，为方便起见，表示为字符串。
-
separatorChar：与系统相关的默认名称，即文件名称分隔符，Windows中为反斜杠“\”，Linux中为正斜杠
-
路径
- 绝对路径：是一个完整的路径，以盘符开始的路径
- 相对路径：是一个简化路径，相对当前项目的根目录
- 注意：
- 路径是不区分大小写的
- 路径中的文件名称分隔符在Windows中是反斜杠，反斜杠是转义字符，两个反斜杠代表一个普通的反斜杠
public class FilePath { public static void main(String[] args) { // D盘下的bbb.java文件 File f = new File("D:\\bbb.java"); System.out.println(f.getAbsolutePath()); // 项目下的bbb.java文件 File f2 = new File("bbb.java"); System.out.println(f2.getAbsolutePath()); } } 输出结果： D:\bbb.java D:\idea_project_test4\bbb.java
-
-
File的常用方法
-
构造方法
- File(String path)：参数是字符串表示的路径，可以是绝对路径，也可以是相对路径。
- File(String parent, String child)：将路径分为父路径和子路径两部分，更灵活。
- File(File parent, String child)：同上，只是父路径变成了File类型，可以通过File的方法对父路径操作。
// 文件路径名 String pathname = "D:\\aaa.txt"; File file1 = new File(pathname); // 文件路径名 String pathname2 = "D:\\aaa\\bbb.txt"; File file2 = new File(pathname2); // 通过父路径和子路径字符串 String parent = "d:\\aaa"; String child = "bbb.txt"; File file3 = new File(parent, child); // 通过父级File对象和子路径字符串 File parentDir = new File("d:\\aaa"); String child = "bbb.txt"; File file4 = new File(parentDir, child);小贴士：
一个File对象代表硬盘中实际存在的一个文件或者目录。
无论该路径下是否存在文件或者目录，都不影响File对象的创建。 -
获取的方法
- getAbsolutePath():获取的就是构造中传入个路径，无论传入的是觉得路径还是相对路径，都会获取绝对路径。
- getPath()：获取的是构造中传入的路径，传入什么路径获取的就是什么路径
- getName()：获取的是构造中传入的结尾，结尾是文件，返回文件名，结尾是文件夹，返回的是文件夹名称。
- length()：返回的是文件的大小，文件夹没有大小，单位是字节数。如果结尾是文件夹，返回0，如果路径不存在，返回0；
public class FileGet { public static void main(String[] args) { File f = new File("d:/aaa/bbb.java"); System.out.println("文件绝对路径:"+f.getAbsolutePath()); System.out.println("文件构造路径:"+f.getPath()); System.out.println("文件名称:"+f.getName()); System.out.println("文件长度:"+f.length()+"字节"); File f2 = new File("d:/aaa"); System.out.println("目录绝对路径:"+f2.getAbsolutePath()); System.out.println("目录构造路径:"+f2.getPath()); System.out.println("目录名称:"+f2.getName()); System.out.println("目录长度:"+f2.length()); } } 输出结果： 文件绝对路径:d:\aaa\bbb.java 文件构造路径:d:\aaa\bbb.java 文件名称:bbb.java 文件长度:636字节 目录绝对路径:d:\aaa 目录构造路径:d:\aaa 目录名称:aaa 目录长度:4096 -
判断的方法
- exists():判断构造中的路径是否存在，存在返回true，否则返回false。
- isDirectory()：判断构造中的路径是否是文件夹，如果否，返回false，如果不存在，返回false，所以使用前用exists判断
- isFile()：判断构造中的路径是否是文件，如果不存在，返回false。
-
创建删除的方法
- createNewFile()：当且仅当具有该名称的文件不存在时，创建一个新的空文件。此方法只能创建文件，不能创建文件夹，创建文件时的路径必须存在，否则抛出异常。
- mkdir()：创建单级文件夹
- mkdirs()：可以创建单级或多级文件夹，只能创建文件夹，不能创建文件。文件夹不存在，创建成功，返回true，存在返回false，如果路径不存在，返回false。
public class FileIs { public static void main(String[] args) { File f = new File("d:\\aaa\\bbb.java"); File f2 = new File("d:\\aaa"); // 判断是否存在 System.out.println("d:\\aaa\\bbb.java 是否存在:"+f.exists()); System.out.println("d:\\aaa 是否存在:"+f2.exists()); // 判断是文件还是目录 System.out.println("d:\\aaa 文件?:"+f2.isFile()); System.out.println("d:\\aaa 目录?:"+f2.isDirectory()); } } 输出结果： d:\aaa\bbb.java 是否存在:true d:\aaa 是否存在:true d:\aaa 文件?:false d:\aaa 目录?:true- delete()：删除File对象所表示的文件or文件夹
-
delete()：删除File对象所表示的文件or文件夹
- 可以删除文件 or 空文件夹
- 不可以删除非空文件夹，如果非要删除，则先把里面的所有文件删除，之后再删除该文件夹
- 删除的路径不存在，返回false，此删除不走回收站，直接删除，慎用。
public class FileCreateDelete { public static void main(String[] args) throws IOException { // 文件的创建 File f = new File("aaa.txt"); System.out.println("是否存在:"+f.exists()); // false System.out.println("是否创建:"+f.createNewFile()); // true System.out.println("是否存在:"+f.exists()); // true // 目录的创建 File f2= new File("newDir"); System.out.println("是否存在:"+f2.exists());// false System.out.println("是否创建:"+f2.mkdir()); // true System.out.println("是否存在:"+f2.exists());// true // 创建多级目录 File f3= new File("newDira\\newDirb"); System.out.println(f3.mkdir());// false File f4= new File("newDira\\newDirb"); System.out.println(f4.mkdirs());// true // 文件的删除 System.out.println(f.delete());// true // 目录的删除 System.out.println(f2.delete());// true System.out.println(f4.delete());// false } } -
File类遍历的方法
- list方法和listFiles方法遍历的是构造中给出的目录，如果构造中给出的目录路径不存在，会抛出异常，如果构造中给出的路径不是一个目录，也会抛出异常。
- list()：返回一个String数组，表示该File目录中的所有子文件或目录，遍历构造中给出的路径，会获取目录汇总所有文件或文件夹的名称，把获取到的名称存储到一个String类型的数组中。可以获取到隐藏文件或文件夹。
- listFiles()：返回一个FIle数组，表示该File目录中所有的子文件或目录，把获取到的子文件或文件夹封装为File对象，多个File对象存储到File类型的数组中。
public class FileFor { public static void main(String[] args) { File dir = new File("d:\\java_code"); //获取当前目录下的文件以及文件夹的名称。 String[] names = dir.list(); for(String name : names){ System.out.println(name); } //获取当前目录下的文件以及文件夹对象，只要拿到了文件对象，那么就可以获取更多信息 File[] files = dir.listFiles(); for (File file : files) { System.out.println(file); } }
-
递归
概述
- 递归：指在当前方法内调用自己的这种现象。
- 递归的分类:
- 递归分为两种，直接递归和间接递归。
- 直接递归称为方法自身调用自己。
- 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。
- 注意事项：
- 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
- 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
- 构造方法,禁止递归
理解
-
理解模型：
从前有座山，山里有个庙，庙里有个老和尚在给小和尚讲故事：
从前有座山，山里有个庙，庙里有个老和尚在给小和尚讲故事：
从前有座山，山里有个庙，庙里有个老和尚在给小和尚讲故事：
…
- 一层嵌套一层，最里面一层不结束，最外面一层就不能结束
- 每一层的内容相同，是自己嵌套自己
-
作用：能把一个很复杂的n阶问题，降为简单的一两层的问题。只需要关注其中某一层的逻辑即可，类比数学归纳法。在代码上的体现就是：能用极其精简的代码解决很复杂的高阶问题
public class Demo01DiGui {
public static void main(String[] args) {
// a();
b(1);
}
/*
* 3.构造方法,禁止递归
* 编译报错:构造方法是创建对象使用的,不能让对象一直创建下去
*/
public Demo01DiGui() {
//Demo01DiGui();
}
/*
* 2.在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
* 4993
* Exception in thread "main" java.lang.StackOverflowError
*/
private static void b(int i) {
System.out.println(i);
//添加一个递归结束的条件,i==5000的时候结束
if(i==5000){
return;//结束方法
}
b(++i);
}
/*
* 1.递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。 Exception in thread "main"
* java.lang.StackOverflowError
*/
private static void a() {
System.out.println("a方法");
a();
}
}
案例
- 计算1+。。。n的和
public class DiGuiDemo {
public static void main(String[] args) {
//计算1~num的和，使用递归完成
int num = 5;
// 调用求和的方法
int sum = getSum(num);
// 输出结果
System.out.println(sum);
}
/*
通过递归算法实现.
参数列表:int
返回值类型: int
*/
public static int getSum(int num) {
/*
num为1时,方法返回1,
相当于是方法的出口,num总有是1的情况
*/
if(num == 1){
return 1;
}
/*
num不为1时,方法返回 num +(num-1)的累和
递归调用getSum方法
*/
return num + getSum(num-1);
}
}
-
求阶乘
5! = 5 * 4! 5! = 5 * (4 * 3!) 5! = 5 * 4 * (3 * 2!) 5! = 5 * 4 * 3 * 2 * 1! 5! = 5 * 4 * 3 * 2 * 1 5! = 5 * 4 * 3 * 2 5! = 5 * 4 * 6 5! = 5 * 24 5! = 120 // 求n的阶乘 public static int fac(int n){ // 入参检查 if(n < 0){ throw new IllegalArgumentException("n不能为负数"); } // 递归出口 if(n == 1 || n == 0){ return 1;// 1和0的阶乘都是1 } return n * fac(n-1); // n! = n * (n-1)! }-
求斐波那契数列第n个数
// 求fibonacci数列中第n个数 public static int fibo(int n){ // 入参检查 if(n <= 0){ throw new IllegalArgumentException("n不能为负数"); } // 开头的两个数都是1 if(n == 1 || n == 2) return 1; // 从第三个数开始，每个数是它前两个数的和 return fibo(n-1)+fibo(n-2); } -
*上台阶
-
*汉诺塔
一层 A --> C 两层 A --> B A --> C B --> C 三层 A --> C A --> B C --> B A --> C 最大圈 B --> A B --> C A --> C -
递归遍历文件夹
public static void files(File file) { //System.out.println(file); File[] files = file.listFiles(f -> f.isDirectory() || f.getName().toLowerCase().endsWith(".java")); for (File f : files) { if (f.isFile()) { System.out.println(f.getName()); }else { files(f); } } }
-
- 递归打印多级目录
public class DiGuiDemo2 {
public static void main(String[] args) {
// 创建File对象
File dir = new File("D:\\aaa");
// 调用打印目录方法
printDir(dir);
}
public static void printDir(File dir) {
// 获取子文件和目录
File[] files = dir.listFiles();
// 循环打印
/*
判断:
当是文件时,打印绝对路径.
当是目录时,继续调用打印目录的方法,形成递归调用.
*/
for (File file : files) {
// 判断
if (file.isFile()) {
// 是文件,输出文件绝对路径
System.out.println("文件名:"+ file.getAbsolutePath());
} else {
// 是目录,输出目录绝对路径
System.out.println("目录:"+file.getAbsolutePath());
// 继续遍历,调用printDir,形成递归
printDir(file);
}
}
}
}
- 文件搜索
- 搜索D:\aaa 目录中的.java 文件。
- 分析：
- 目录搜索，无法判断多少级目录，所以使用递归，遍历所有目录。
- 遍历目录时，获取的子文件，通过文件名称，判断是否符合条件。
- 代码实现
public class DiGuiDemo3 {
public static void main(String[] args) {
// 创建File对象
File dir = new File("D:\\aaa");
// 调用打印目录方法
printDir(dir);
}
public static void printDir(File dir) {
// 获取子文件和目录
File[] files = dir.listFiles();
// 循环打印
for (File file : files) {
if (file.isFile()) {
// 是文件，判断文件名并输出文件绝对路径
if (file.getName().endsWith(".java")) {
System.out.println("文件名:" + file.getAbsolutePath());
}
} else {
// 是目录，继续遍历,形成递归
printDir(file);
}
}
}
}
文件过滤器
概述
- 文件过滤器：通过listfiles方法，可以获取到一个目录下的所有文件和文件夹，通过某个条件来进行筛选。
- 可以自定义文件过滤器，自己编写条件，返回值是boolean
分类
- File类的两种过滤器接口：
- FilenameFilter：需要实现的方法boolean accept(File dir, String name);
- FileFilter：需要实现的方法boolean accept(File pathname);
使用
- 过滤器的使用方法：
- 首先创建过滤器实例，然后在File类的list()和listFiles()中使用过滤器实例作为参数。
- 由于过滤器是接口。所以需要写实现类，或者使用匿名内部类的形式，由于该接口中只有一个方法，所以可以使用Lambda方式实现
实现
- 实现
FilenameFilter接口的过滤器实例
public class FilterByName implements FilenameFilter{
private String sufix;
public FilterByName(String sufix){
this.sufix = sufix;
}
@Override
public boolean accept(File dir, String name) {
if(name.endsWith(sufix)) return true;
else return false;
}
}
- 实现
FileFilter接口的过滤器实例
public class FilterByPath implements FileFilter {
private String sufixName;
public FilterByPath(String sufixName){
this.sufixName = sufixName;
}
@Override
public boolean accept(File pathname) {
String name = pathname.getName();
if(name.endsWith(sufixName)) return true;
else return false;
}
}
- 使用场景，在某个目录下过滤出后缀为".exe"的文件。
- 第一种方法：File[] listFiles(FileFilter filter);
@Test
public void testCase1(){
File file = new File("E:\\learn_materials\\资料");
FilterByPath fbp = new FilterByPath(".exe");
File[] arr = file.listFiles(fbp);
System.out.println(arr.length);
for(File f:arr){
System.out.println(f);
}
}
- 第二种：File[] listFiles(FilenameFilter filter)
@Test
public void testCase2(){
File file = new File("E:\\learn_materials\\资料");
FilterByName fbn = new FilterByName(".exe");
File[] arr = file.listFiles(fbn);
System.out.println(arr.length);
for(File f:arr){
System.out.println(f);
}
}
- 第三种：String[] list(FilenameFilter filter)
@Test
public void testCase3(){
File file = new File("E:\\learn_materials\\资料");
FilterByName fbn = new FilterByName(".exe");
String[] arr = file.list(fbn);
System.out.println(arr.length);
for(String f:arr){
System.out.println(f);
}
}
- listFiles()方法可以使用FilenameFilter和FileFilter过滤器，list()方法只能使用FilenameFilter过滤器。
891
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
