1.File类

File类：

  • 文件进行持久化数据的工具—持久化：将缓存中的文件（对象）永久保存
  • File类的一个对象就代表一个文件或者是文件夹—理解
  • 文档上说明File类文件或者是文件路径，我们可以通过这个路径找到相对应的文件或者是文件夹

  • 构造方法：
  • public File(String pathName)—路径 ```java package com.igeek_01;

/**

  • @author Lynn
  • @create 2020-12-10-9:30 */

import java.io.File; import java.lang.reflect.Member;

/**

  • File类：
  • 文件进行持久化数据的工具—持久化：将缓存中的文件（对象）永久保存
  • File类的一个对象就代表一个文件或者是文件夹—理解
  • 文档上说明File类文件或者是文件路径，我们可以通过这个路径找到相对应的文件或者是文件夹 *
  • 构造方法：

  • public File(String pathName)—路径 */ public class FileDemo { public static void main(String[] args) {

    1.  //查找文件--保证文件是存在的
    2.  File f=new File("F:\\A_Java\\workspaces\\javaadvanced_workspaces\\upper_day09\\test.txt");
    3.  System.out.println(f);
    4.  System.out.println(f.length());//文件大小
    6.  File dir= new File("F:/A_Java/workspaces/javaadvanced_workspaces/upper_day09/other");
    7.  System.out.println(dir);
    8.  System.out.println(dir.length());//当前文件夹大小
    9.  System.out.println(dir.lastModified());//当前文件夹最后一次修改的时间--毫秒值

    } } ```

    路径解释

    路径解释：

  • 1.绝对路径：从盘符开始到文件的路径—相当于是一个地址
  • 2.相对路径：从某个参照路径开始到指定文件的路径

  • 在路径的书写过程中，所有的文件如果想要使用相对路径，则参照的路径都是根目录

  • 在Java中，对于分辨路径的分隔符可以支持两种方式：/或者\,是通用的 ```java package com.igeek_02;

/**

  • @author Lynn
  • @create 2020-12-10-9:30 */

import java.io.File;

/**

  • 路径解释：
  • 1.绝对路径：从盘符开始到文件的路径—相当于是一个地址
  • 2.相对路径：从某个参照路径开始到指定文件的路径 *
  • 在路径的书写过程中，所有的文件如果想要使用相对路径，则参照的路径都是根目录 *

  • 在Java中，对于分辨路径的分隔符可以支持两种方式：/或者\,是通用的 */ public class FileDemo { public static void main(String[] args) {

    1.  //查找文件--保证文件是存在的
    2.  //演示绝对路径
    3.  File f=new File("F:\\A_Java\\workspaces\\javaadvanced_workspaces\\upper_day09\\a\\b\\test.txt");
    4.  System.out.println(f);
    5.  System.out.println(f.length());//文件大小
    7.  //相对路径
    8.  File dir= new File("a/b/test.txt");
    9.  System.out.println(dir);
    10.  System.out.println(dir.length());

    } } ```

    File类中的方法讲解1

  • 构造函数：
  • public File(String parent,String child):parent指的是父级目录，child指的是子级目录
  • 1.直接给与路径（绝对路径，相对路径）
  • 2.路径为父亲（该文件夹或者是文件所在的文件夹）与孩子（该文件夹自己的名字或者是文件）

  • 说明：
  • 在new File() 的时候，只是将File对象在内存中实例化了，实际上并没有真正的创建文件！！
  • 所以需要本身这个文件，才可以通过传入路径找到这个文件 ```java package com.igeek_03;

/**

  • @author Lynn
  • @create 2020-12-10-9:30 */

import java.io.File;

/**

  • File类中的方法讲解1 *
  • 构造函数：
  • public File(String parent,String child):parent指的是父级目录，child指的是子级目录
  • 1.直接给与路径（绝对路径，相对路径）
  • 2.路径为父亲（该文件夹或者是文件所在的文件夹）与孩子（该文件夹自己的名字或者是文件） *
  • 说明：
  • 在new File() 的时候，只是将File对象在内存中实例化了，实际上并没有真正的创建文件！！

  • 所以需要本身这个文件，才可以通过传入路径找到这个文件 */ public class FileMethod1 { public static void main(String[] args) { //通过父亲与孩子的构造方法创建test.txt File file=new File(“a/b/“,”test.txt”); //长度与实际的文件长度不符合（通常为0）表示文件不存在 System.out.println(file.length());

    //通过父亲与孩子的构造函数 创建a文件夹下的b文件夹所对应的对象 File dir=new File(“a”,”b”); System.out.println(dir.length()); System.out.println(dir.lastModified());

    } } ```

    File类中的方法讲解2

  • 获取的方法：
  • 常用：
  • 1.获取文件/文件夹信息的方法
  • String getAbsolutePath()—获取绝对路径
  • String getPath()—————获取路径（用什么方式创建对象，就返回什么方式的路径—绝对或者是相对）
  • String getName()—————获取文件或者文件夹的名字
  • String getParent()————返回所在文件夹的路径（根据创建对象时候的路径—绝对或者是相对） ```java package com.igeek_04;

/**

  • @author Lynn
  • @create 2020-12-10-9:30 */

import java.io.File;

/**

  • File类中的方法讲解2 *
  • 获取的方法：
  • 常用：
  • 1.获取文件/文件夹信息的方法
  • String getAbsolutePath()—获取绝对路径
  • String getPath()—————获取路径（用什么方式创建对象，就返回什么方式的路径—绝对或者是相对）
  • String getName()—————获取文件或者文件夹的名字

  • String getParent()————返回所在文件夹的路径（根据创建对象时候的路径—绝对或者是相对） */ public class FileMethod2 { public static void main(String[] args) {

    1.  //创建对象
    2.  File file=new File("a/b/test.txt");//相对路径
    3.  File file2=new File("F:\\A_Java\\workspaces\\javaadvanced_workspaces\\upper_day09\\a\\b\\test.txt");//绝对路径
    4.  File file3=new File("a/b");//相对路径
    6.  //获取方法演示
    7.  System.out.println(file.getPath());// 相对路径
    8.  System.out.println(file2.getPath());//绝对路径
    10.  System.out.println("-----------------------------------");
    12.  //将相对路径按照绝对路径的格式打印
    13.  System.out.println(file.getAbsoluteFile());
    14.  System.out.println(file3.getAbsoluteFile());
    16.  System.out.println("-----------------------------------");
    18.  System.out.println(file.getName());// test.txt
    19.  System.out.println(file3.getName());// b
    21.  System.out.println("-----------------------------------");
    23.  System.out.println(file.getParent());// a\b
    24.  System.out.println(file2.getParent());// 绝对路径
    25.  System.out.println(file3.getParent());// a

    } } ```

    File类中的方法讲解3

  • File类中可以删除和创建文件（java中删除时不使用window的回收站）

  • 方法：
  • boolean delete()—删除文件
  • boolean creatNewFile()—创建一个文件—抛出一个异常IOException
  • 在创建文件的时候，如果文件所在的文件夹不存在，则会报错系统找不到路径，
  • 必须确保父级文件夹存在！！！

  • boolean mkdir()—创建文件夹

  • 在创建文件夹的时候，如果文件夹所在的父级文件夹不存在，则会报错系统找不到路径，
  • 必须确保父级文件夹存在！！！

  • boolean mkdirs()—创建多个文件夹
  • boolean delete()—注意：删除文件夹的时候不能为非空（有东西），否则删除失败 ```java package com.igeek_05;

/**

  • @author Lynn
  • @create 2020-12-10-9:30 */

import java.io.File; import java.io.IOException;

/**

  • File类中的方法讲解3 *
  • File类中可以删除和创建文件（java中删除时不使用window的回收站） *
  • 方法：
  • boolean delete()—删除文件
  • boolean creatNewFile()—创建一个文件—抛出一个异常IOException
  • 在创建文件的时候，如果文件所在的文件夹不存在，则会报错系统找不到路径，
  • 必须确保父级文件夹存在！！！ *
  • boolean mkdir()—创建文件夹
    • 在创建文件夹的时候，如果文件夹所在的父级文件夹不存在，则会报错系统找不到路径，
  • 必须确保父级文件夹存在！！！ *
  • boolean mkdirs()—创建多个文件夹
  • boolean delete()—注意：删除文件夹的时候不能为非空（有东西），否则删除失败 */ public class FileMethod3 { public static void main(String[] args) throws IOException {
    1.  //创建对象
    2.  File file=new File("a/b/test.txt");//相对路径
  1.     //删除文件

// System.out.println(file.getPath()+”，删除结果：”+ file.delete());

  1.     //创建文件

// System.out.println(file.getPath()+”，创建结果：”+ file.createNewFile());

  1.     //演示创建文件的时候父级文件夹不存在的情况
  2.     File file1=new File("c/d/test.txt");//相对路径

// System.out.println(file1.getPath()+”，创建结果：”+ file1.createNewFile());//系统找不到指定路径

  1.     /*//创建文件夹
  2.     File file2=new File("c/d");//相对路径
  3.     System.out.println(file2.mkdir());//false*/
  5.     //创建文件夹
  6.     File file2=new File("a/c");//相对路径

// System.out.println(file2.mkdir());//true

  1.     File dir=new File("e1/e2");//保证e1存在
  2.     System.out.println(dir.mkdir());
  4.     //同时删除多个文件夹
  5.     File dir2=new File("e1/f/g/h/i/k");
  6.     System.out.println(dir2.mkdirs());
  8.     //删除
  9.     //这里只是删除了最里面的那个文件夹，而且这个文件夹是空的

// System.out.println(dir.delete());//删除的是e2文件夹 // System.out.println(dir2.delete());//删除的是k文件夹

  1.     //演示不是空的文件夹能不能删除
  2.     File ff=new File("a/b");
  3.     System.out.println(ff.delete());//false
  5. }

}

  1. <a name="0209b0b4"></a>
  2. ### File类中的方法讲解4
  4. - File类中的判断的方法--返回值基本都是boolean类型
  5. - <br />
  6. - 方法：
  7. - boolean exists()-- 判断文件或者是文件夹是否存在
  8. - boolean isDirectory()--判断文件对象是否为文件夹（目录）
  9. - boolean ifFile()---判断这个文件对象是不是文件
  10. ```java
  11. package com.igeek_06;
  13. /**
  14.  * @author Lynn
  15.  * @create 2020-12-10-9:30
  16.  */
  18. import java.io.File;
  19. import java.io.IOException;
  21. /**
  22.  * File类中的方法讲解4
  23.  *
  24.  * File类中的判断的方法--返回值基本都是boolean类型
  25.  *
  26.  * 方法：
  27.  * boolean exists()-- 判断文件或者是文件夹是否存在
  28.  * boolean isDirectory()--判断文件对象是否为文件夹（目录）
  29.  * boolean ifFile()---判断这个文件对象是不是文件
  30.  *
  31.  */
  32. public class FileMethod4 {
  33.     public static void main(String[] args) throws IOException {
  34.         //创建对象
  35.         File file1=new File("a/b/test.txt");//相对路径
  36.         File file2=new File("a/b/c.test.txt");//相对路径
  37.         File dir=new File("c/d");//相对路径
  38.         File dir2=new File("e1/e2");//相对路径
  40.         //判断文件或者文件夹是否存在
  41.         System.out.println(file1.exists());// true
  42.         System.out.println(file2.exists());// false
  43.         System.out.println(dir.exists());// false
  44.         System.out.println(dir2.exists());// true
  46.         System.out.println("-------------------------------------------");
  48.         //判断是文件还是文件夹
  49.         System.out.println(file1.isFile());
  50.         System.out.println(file1.isDirectory());
  51.         System.out.println(dir.isDirectory());//false--如果不存在返回的也是false
  52.         System.out.println(file2.isFile());//false--如果不存在返回的也是false
  54.     }
  55. }

File类中的方法讲解5

  • 用来获取所有的文件对象的方法

  • File[] listFile()— 获取调用方法的文件夹下的所有的file对象（文件夹或者文件） ```java package com.igeek_07;

/**

  • @author Lynn
  • @create 2020-12-10-9:30 */

import java.io.File; import java.io.IOException;

/**

  • File类中的方法讲解5 *
  • 用来获取所有的文件对象的方法 *

  • File[] listFile()— 获取调用方法的文件夹下的所有的file对象（文件夹或者文件） */ public class FileMethod5 { public static void main(String[] args) throws IOException {

    1.  //创建对象
    2.  /**
    3.   * .表示当前的文件夹所在的位置（父级目录）
    4.   * ..表示上一级目录（父级目录）
    5.   */
    6.  File dir=new File("./");//表示当前项目的根目录
    8.  //获取该文件夹下的所有的文件对象
    9.  File[] filesDirs=dir.listFiles();
    11.  //遍历文件数组
    12.  for (File fileDir:filesDirs){
    13.      System.out.println(fileDir);
    14.  }

    } } ```

2.递归方法基础：

  • 递归：自己调用自己
  • 分成两种：
  • 1.直接—当前方法直接调用自己
  • 2.间接—方法A调用方法B，方法B调用方法C，方法C调用方法A

  • 方法是可以相互调用的：
  • 使用递归的时候要注意：设置递归出口—-结束条件 ```java package com.igeek_08;

/**

  • @author Lynn
  • @create 2020-12-10-15:23 */

/**

  • 递归方法基础： *
  • 递归：自己调用自己
  • 分成两种：
  • 1.直接—当前方法直接调用自己
  • 2.间接—方法A调用方法B，方法B调用方法C，方法C调用方法A *
  • 方法是可以相互调用的：

  • 使用递归的时候要注意：设置递归出口—-结束条件 */ public class DiguiDemo { //成员变量 private static int i=1;

    public static void main(String[] args) {

    1.  methodA();

    } //模拟递归 public static void methodA(){

    1.  System.out.println("方法A："+i);
    2.  i++;
    3.  methodB();
    4.  i++;
    5.  System.out.println("方法A："+i);

    }

    public static void methodB(){

    1.  System.out.println("方法B："+i);
    2.  i++;
    3.  methodC();
    4.  i++;
    5.  System.out.println("方法B："+i);

    } public static void methodC(){

    1.  System.out.println("方法C："+i);
    2.  i++;
    3.  methodD();
    4.  i++;
    5.  System.out.println("方法C："+i);

    } public static void methodD(){

    1.  System.out.println("方法D："+i);

    } } ```

    递归的算法：

  • 方法自身调用自身的方法，必须要有方法的出口（可以结束方法的条件），递归的次数不宜过多
  • 容易造成栈内存溢出错误—StsckOverflowError

  • 运行过程：
  • main-method_1(没有结束)-method_2(没有结束)-method_3(没有结束)-method_4(没有结束)-method_5(结束)-
  • method_6(结束)-method_7(结束) ```java package com.igeek_08;

/**

  • @author Lynn
  • @create 2020-12-10-15:36 */

/**

  • 递归的算法：
  • 方法自身调用自身的方法，必须要有方法的出口（可以结束方法的条件），递归的次数不宜过多
  • 容易造成栈内存溢出错误—StsckOverflowError *
  • 运行过程：
  • main-method_1(没有结束)-method_2(没有结束)-method_3(没有结束)-method_4(没有结束)-method_5(结束)-

  • method_6(结束)-method_7(结束) */ public class DiguiDemo2 { //成员变量 private static int i=1;

    public static void main(String[] args) {

    1.  method();

    } //模拟递归 public static void method(){

    1.  System.out.println("方法开始："+i);
    2.  //是指递归的出口
    3.  if (i==4){
    4.      return;//结束方法并且返回结果
    5.  }
    7.  i++;
    8.  method();
    9.  i++;
    10.  System.out.println("方法结束："+i);

    } } ```

    计算阶乘的实现—利用递归

  • 阶乘：
  • 5！=5_4_3_2_1

  • 5！=5*4！

    1. 4！=4*3！
    1.       3！=3*2！
    1.           2！=2*1！
    1.                 1！=1


  • 逻辑中除了1！不需要计算
  • 其他使用递归处理

  • 两个条件：
  • 递归逻辑：当这个数*（这个数-1）的阶乘
  • 递归出口：当这个阶乘到达1的时候，不再阶乘 ```java package com.igeek_08;

/**

  • @author Lynn
  • @create 2020-12-10-16:02 */

/**

  • 计算阶乘的实现—利用递归 *
  • 阶乘：
  • 5！=54321
  • 5！=5*4！
  • 4！=4*3！
  • 3！=3*2！
  • 2！=2*1！
  • 1！=1 *
  • 逻辑中除了1！不需要计算
  • 其他使用递归处理 *
  • 两个条件：
  • 递归逻辑：当这个数*（这个数-1）的阶乘
  • 递归出口：当这个阶乘到达1的时候，不再阶乘 */ public class DiguiTest1 { public static void main(String[] args) {
    1.  int result=5;
    2.  System.out.println(method(result));
    } //递归其实就是循环的另一种体现 //封装方法—求某个数字的阶乘—递归逻辑 public static int method(int n){
    1.  //方法出口
    2.  if (n==1){
    3.      return 1;
    4.  }
    5.  //如果不是1就继续算
    6.  return n*method(n-1);
    } } ```

    递归打印多级文件夹的路径：

  • 分析：
  • 1.定义一个方法，就收文件夹，打印该文件夹中所有文件的路径
  • 2.获取该文件夹中所有的文件对象
  • 3.判断该文件对象是文件夹还是文件
  • 如果是文件，直接打印路径
  • 如果是文件夹，调用方法，打印该文件夹中所有的文件的路径 ```java package com.igeek_08;

/**

  • @author Lynn
  • @create 2020-12-10-16:13 */

import java.io.File;

/**

  • 递归打印多级文件夹的路径： *
  • 分析：
  • 1.定义一个方法，就收文件夹，打印该文件夹中所有文件的路径
  • 2.获取该文件夹中所有的文件对象
  • 3.判断该文件对象是文件夹还是文件
  • 如果是文件，直接打印路径

  • 如果是文件夹，调用方法，打印该文件夹中所有的文件的路径 / public class DiguiTest2 { public static void main(String[] args) { //设置总路径—项目根路径 File dir=new File(“./“); method(dir); }

    //封装一个方法用于实现递归，打印所有文件夹下的所有的文件路径 public static void method(File dir){ //获取文件夹下的所有的文件对象 File[] filesDirs=dir.listFiles(); //遍历 for (File fileDir:filesDirs){

    1.    //判断是文件夹还是文件
    2.    if (fileDir.isFile()){
    3.        //直接打印路径
    4.        System.out.println(fileDir.getAbsolutePath());
    5.    }else {
    6.        //文件夹--再次调用该方法
    7.        method(fileDir);
    8.    }

    } } } ```