Lesson19_IO_File_递归

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过滤器。

你可能感兴趣的:(笔记,教案,javase,java)