Java基础----【File类、递归】

主要内容

• File类
• 递归

第一章 File类

1.1 概述

java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。

import java.util.ArrayList;
import java.util.Collections;

public class FileConstructorTest {
    public static void main(String[] args) {

        // 请问 : 为什么要学习 File 类 ???  File 代表 `文件和目录 (文件夹)`.
        // File 在硬盘上的形式, 类似于数据的永久性存储. (关闭后, 重新开机, 数据依然存在)

        // 程序中的数据, `变量, 数组, 集合`, 程序一旦结束, 所有程序中的数据都会被销毁.
        int num = 10;
        int[] arr = {10, 20, 30, 40, 50};
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张三", "李四", "王五");

        // 请问 : 如果我们想将程序中的数据, 实现永久性的存储, 如何做呢 ???
        // 程序如何与硬盘实现交互 ???
        // 方向1 : 将程序中的数据写入到硬盘, 实现永久性存储.
        // 方向2 : 从硬盘中将数据读取到程序中, 实现操作.

        // 参照物 : 内存
        // 输入流 : 从硬盘上流入到内存的操作类, 被称为输入流类.       InputStream / Reader
        // 输出流 : 从内存中写出到硬盘中的操作类, 被称为输出流类.     OutputStream / Writer

        // 流分成两大类 :
        // 字节流 : 所有数据皆字节数据. (文字, 图片, 音频, 视频 ...) 01010101010...
        // 字符流 : 字节流 + 编码表(翻译)   `中国人` (2个字节 `GBK` / 3个字节 `UTF-8`)

        // File类 : 所有数据最终都存储在文件中, 文件可以存储到文件夹中进行管理.
    }
}

1.2 构造方法

• public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。

• public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。

• public File(File parent, String child) ：从父抽象路径名和子路径名字符串创建新的 File实例。

• 构造举例，代码如下：

import java.io.File;

public class FileConstructorTest2 {
    public static void main(String[] args) {

        // 需求 : 如何创建一个 File 对象
        // File 类的说明 : 文件和目录路径名的抽象表示
        // 目的 : 创建文件, 创建文件夹, 判断是文件还是文件夹, 删除文件, 重命名 ...

        // 1. public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
        File file1 = new File("D:\\aaa.txt");
        System.out.println("file1 = " + file1);

        // 2. public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。
        String parent = "D:\\aaa";
        String child = "aaa.txt";
        File file2 = new File(parent, child);
        System.out.println("file2 = " + file2);

        // 3. public File(File parent, String child) ：从父抽象路径名和子路径名字符串创建新的 File实例。
        File parent2 = new File("D:\\aaa");
        String child2 = "aaa.txt";
        File file3 = new File(parent2, child2);
        System.out.println("file3 = " + file3);
    }
}

输出结果 :
file1 = D:\aaa.txt
file2 = D:\aaa\aaa.txt
file3 = D:\aaa\aaa.txt

小贴士：

1. 一个File对象代表硬盘中实际存在的一个文件或者目录。
2. 无论该路径下是否存在文件或者目录，都不影响File对象的创建。

1.3 常用方法

获取功能的方法

• public String getAbsolutePath() ：返回此File的绝对路径名字符串。

• public String getPath() ：将此File转换为路径名字符串。

• public String getName() ：返回由此File表示的文件或目录的名称。

• public long length() ：返回由此File表示的文件的长度。

  方法演示，代码如下：

  import java.io.File;
  
  public class FileMethodTest3 {
      public static void main(String[] args) {
  
          // 绝对路径 : 从根盘符开始的路径, 被称为 `绝对路径`.
          // 相对路径 : 针对当前而言.
  
          File file1 = new File("D:/aaa.txt");        // 绝对路径
          File file2 = new File("aaa.txt");           // 相对路径 (相对当前项目而言)
  
          //- public String getAbsolutePath() ：返回此File的绝对路径名字符串。
          System.out.println("file1的绝对路径 : " + file1.getAbsolutePath());
          System.out.println("file2的绝对路径 : " + file2.getAbsolutePath());
  
          //- public String getPath() ：将此File转换为路径名字符串。  (构造路径)
          System.out.println("file1的构造路径 : " + file1.getPath());
          System.out.println("file2的构造路径 : " + file2.getPath());
  
          //- public String getName()  ：返回由此File表示的文件或目录的名称。
          System.out.println("file1对象的文件名称 : " + file1.getName());
          System.out.println("file2对象的文件名称 : " + file2.getName());
  
          //- public long length()  ：返回由此File表示的文件的长度。
          System.out.println("file1对象的文件长度为 : " + file1.length());   // 文件中数据的字节数
  
          File file = new File("D:/aaa");  // 如果此路径名表示目录，则返回值未指定。
          System.out.println("file文件夹的长度 : " + file.length());   // 说明 : 获取文件夹的长度是不固定的.
      }
  }
  
  输出结果：
  file1的绝对路径 : D:\aaa.txt
  file2的绝对路径 : D:\Java\IdeaProjects\44期\Day08\aaa.txt
  file1的构造路径 : D:\aaa.txt
  file2的构造路径 : aaa.txt
  file1对象的文件名称 : aaa.txt
  file2对象的文件名称 : aaa.txt
  file1对象的文件长度为 : 1508
  file文件夹的长度 : 0
  

API中说明：length()，表示文件的长度。但是File对象表示目录，则返回值未指定。

绝对路径和相对路径

• 绝对路径：从盘符开始的路径，这是一个完整的路径。
• 相对路径：相对于项目目录的路径，这是一个便捷的路径，开发中经常使用。

import java.io.File;

public class Test3 {
    public static void main(String[] args) {

        // 绝对路径 : 从盘符开始的路径, 这是一个完整的路径.
        File file1 = new File("D:\\bbb.java");
        System.out.println("file1 = " + file1.getAbsolutePath());

        // 相对路径 : 相对于项目目录的路径, 这是一个便捷的路径, 开发中经常使用.
        File file2 = new File("bbb.java");
        System.out.println("file2 = " + file2.getAbsolutePath());
    }
}

输出结果：
file1 = D:\bbb.java
file2 = D:\Java\IdeaProjects\MyTest1\bbb.java

判断功能的方法

• public boolean exists() ：此File表示的文件或目录是否实际存在。
• public boolean isDirectory() ：此File表示的是否为目录。
• public boolean isFile() ：此File表示的是否为文件。

方法演示，代码如下：

import java.io.File;

public class Test4 {
    public static void main(String[] args) {

        File file1 = new File("D:\\aaa\\bbb.java");
        File file2 = new File("D:\\aaa");

        // public boolean exists() ：此File表示的文件或目录是否实际存在。
        System.out.println("file1描述的文件是否存在 : " + file1.exists());
        System.out.println("file2描述的目录是否存在 : " + file2.exists());

        // public boolean isDirectory() ：此File表示的是否为目录。
        System.out.println("file1描述的是目录吗 ? " + file1.isDirectory());
        System.out.println("file2描述的是目录吗 ? " + file2.isDirectory());

        // public boolean isFile() ：此File表示的是否为文件。
        System.out.println("file1描述的是文件吗 ? " + file1.isFile());
        System.out.println("file2描述的是文件吗 ? " + file2.isFile());
    }
}

输出结果：
file1描述的文件是否存在 : true
file2描述的目录是否存在 : true
file1描述的是目录吗 ? false
file2描述的是目录吗 ? true
file1描述的是文件吗 ? true
file2描述的是文件吗 ? false

创建删除功能的方法

• public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
• public boolean delete() ：删除由此File表示的文件或目录。
• public boolean mkdir() ：创建由此File表示的目录。
• public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。

方法演示，代码如下：

文件的创建演示 :

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

public class Test5 {
    public static void main(String[] args) throws IOException {

        File file1 = new File("D:\\aaa.txt");

        System.out.println("file1表示的文件是否存在 ? " + file1.exists());

        // public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
        boolean result = file1.createNewFile();
        System.out.println("file1表示的文件是否创建 ? " + result);

        System.out.println("file1表示的文件是否存在 ? " + file1.exists());
    }
}

输出结果 :
file1表示的文件是否存在 ? false
file1表示的文件是否创建 ? true
file1表示的文件是否存在 ? true

目录的创建演示 :

import java.io.File;

public class Test6 {
    public static void main(String[] args) {

        File file1 = new File("D:\\bbb");

        System.out.println("file1表示的目录是否存在 ? " + file1.exists());

        // public boolean mkdir() ：创建由此File表示的目录。
        boolean result = file1.mkdir();
        System.out.println("file1表示的目录是否创建成功 ? " + result);

        System.out.println("file1表示的目录是否存在 ? " + file1.exists());

        System.out.println("-----------------------------");

        File file2 = new File("D:\\ccc\\ddd\\eee");
        System.out.println("file2表示的目录是否存在 ? " + file2.exists());

        // public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。
        boolean result2 = file2.mkdirs();
        System.out.println("file2表示的目录是否创建成功 ? " + result2);
        
        System.out.println("file2表示的目录是否存在 ? " + file2.exists());
    }
}

输出结果 :
file1表示的目录是否存在 ? true
file1表示的目录是否创建成功 ? false
file1表示的目录是否存在 ? true
-----------------------------
file2表示的目录是否存在 ? false
file2表示的目录是否创建成功 ? true
file2表示的目录是否存在 ? true

删除文件与目录 :

import java.io.File;

public class Test7 {
    public static void main(String[] args) {

        // public boolean delete() ：删除由此File表示的文件或目录。

        File file1 = new File("D:\\aaa.txt");
        File file2 = new File("D:\\aaa");
        File file3 = new File("D:\\bbb");

        System.out.println("file1文件是否删除成功 ? " + file1.delete());
        System.out.println("file2非空文件夹是否删除成功 ? " + file2.delete());
        System.out.println("file3空文件夹是否删除成功 ? " + file3.delete());
    }
}

输出结果 :
file1文件是否删除成功 ? true
file2非空文件夹是否删除成功 ? false
file3空文件夹是否删除成功 ? true

API中说明：delete方法，如果此File表示目录，则目录必须为空才能删除。

补充说明 : 在文件夹中直接创建文件, 一步到位, 如何实现 ???

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

public class FileCreateFileTest3 {
    public static void main(String[] args) throws IOException {

        File file = new File("D:/zzz/yyy/hello.txt");

        // 创建文件
        // 注意点 : 如果创建文件的父目录不存在, 文件就会创建失败!

        // 1. 获取文件的父目录对象
        File parentFile = file.getParentFile();

        // 2. 判断父目录文件夹是否存在
        if (parentFile.exists() == false) {

            // 3. 如果父目录不存在, 需要创建父目录
            parentFile.mkdirs();
        }

        // 4. 程序来到这里, 就能够保证父目录文件夹一定存在. 文件就可以被创建成功.
        boolean result = file.createNewFile();
        System.out.println("result = " + result);
    }
}

输出结果 :
result = true

1.4 目录的遍历

• public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。

• public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。

import java.io.File;

public class Test8 {
    public static void main(String[] args) {

        File file = new File("D:\\课程资料");

        // public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
        String[] names = file.list();
        for (String name : names) {
            System.out.println(name);
        }

        System.out.println("--------------");

        // public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
        File[] files = file.listFiles();
        for (File f : files) {
            System.out.println(f);
        }
    }
}

输出结果 :
1.jpg
2.jpg
3.jpg
--------------
D:\课程资料\1.jpg
D:\课程资料\2.jpg
D:\课程资料\3.jpg

小贴士：

调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历。

第二章 递归

2.1 概述

• 递归：指在当前方法内调用自己的这种现象。

public class Test1 {
    public static void main(String[] args) {

        System.out.println("main");

        // StackOverflowError 栈内存溢出错误!
        main(args);
    }
}

2.2 递归累和

计算1 ~ n的和

分析：num的累和 = num + (num-1)的累和，所以可以把累和的操作定义成一个方法，递归调用。

实现代码：

public class Test2 {
    public static void main(String[] args) {

        // 需求 : 计算 1 ~ n 的累积和
        // num = 5; result = 5 + 4 + 3 + 2 + 1;

        // 方式一 : 打印实现
        System.out.println(5 + 4 + 3 + 2 + 1);

        // 方式二 : 循环实现
        int num = 5;
        int result = 0;
        for (int i = num; i >= 1; i--) {
            result += i;
        }
        System.out.println("result = " + result);

        // 方式三 : 递归实现
        /*
        问 : 1到5的累加值是多少 ???  不知道, 但是等于 5 + 1到4的累加和.
        问 : 1到4的累加值是多少 ???  不知道, 但是等于 4 + 1到3的累加和.
        问 : 1到3的累加值是多少 ???  不知道, 但是等于 3 + 1到2的累加和.
        问 : 1到2的累加值是多少 ???  不知道, 但是等于 2 + 1到1的累加和.
        问 : 1到1的累加值是多少 ???  等于 1.
         */
        int sum = getResult(5);
        System.out.println("sum = " + sum);
    }

    // 定义一个方法 : 求指定数值的累加和
    public static int getResult(int num) {
        if (num == 1) {
            return 1;
        } else {
            return num + getResult(num - 1);
        }
    }
}

代码执行图解

小贴士：递归一定要有条件限定，保证递归能够停止下来，次数不要太多，否则会发生栈内存溢出。

2.3 递归求阶乘

• 阶乘：所有小于及等于该数的正整数的积。

n的阶乘：n! = n * (n-1) *...* 3 * 2 * 1 

分析：这与累和类似,只不过换成了乘法运算，学员可以自己练习，需要注意阶乘值符合int类型的范围。

推理得出：n! = n * (n-1)!

代码实现：

public class Test3 {
    public static void main(String[] args) {

        // 方式 : 递归实现
        /*
        问 : 5的阶乘是多少 ???  不知道, 但是5的阶乘等于 5 * 4的阶乘.
        问 : 4的阶乘是多少 ???  不知道, 但是4的阶乘等于 4 * 3的阶乘.
        问 : 3的阶乘是多少 ???  不知道, 但是3的阶乘等于 3 * 2的阶乘.
        问 : 2的阶乘是多少 ???  不知道, 但是2的阶乘等于 2 * 1的阶乘.
        问 : 1的阶乘是多少 ???  1的阶乘等于 1.
         */

        int result = getFactorial(5);
        System.out.println("result = " + result);
    }

    public static int getFactorial(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n * getFactorial(n - 1);
        }
    }
}

输出结果 :
result = 120

求年龄 : 有 5 个人, 问 : 第 5 个人多大 ? 我比第 4 个人大 2 岁. 问 : 第 4 个人多大 ? 我比第 3 个人大 2 岁…第1个人10岁, 请问, 第5个人多大 ???

public class RecursiveCallTest3 {
    public static void main(String[] args) {

        /*
        需求 : 有 5 个人,
        问 : 第 5 个人多大 ? 我比第 4 个人大 2 岁.
        问 : 第 4 个人多大 ? 我比第 3 个人大 2 岁.
        问 : 第 3 个人多大 ? 我比第 2 个人大 2 岁.
        问 : 第 2 个人多大 ? 我比第 1 个人大 2 岁.
        问 : 第 1 个人多大 ? 第 10 岁.

        步骤一 : 定义一个方法.       int getAge(int n);
        步骤二 : 结束递归 ???        n == 1; return 10;
        步骤三 : 继续递归 ???        n != 1; getAge(n - 1) + 2;

         */
        int age = getAge(5);
        System.out.println("age = " + age);
    }

    // 求年龄
    public static int getAge(int n) {
        if (n == 1) {
            return 10;
        } else {
            return getAge(n - 1) + 2;
        }
    }
}

输出结果 :
age = 18

2.4 递归打印多级目录

分析：多级目录的打印，就是当目录的嵌套。遍历之前，无从知道到底有多少级目录，所以我们还是要使用递归实现。

代码实现：

import java.io.File;

public class Test4 {
    public static void main(String[] args) {

        // 递归打印多级目录 :
        File file = new File("D:\\课程资料");

        // 调用方法
        scanFolders(file);
    }

    public static void scanFolders(File file) {
        // listFiles();
        File[] files = file.listFiles();
        // 遍历
        for (File f : files) {
            // 判断是否为文件夹
            if (f.isDirectory()) {
                // 递归调用 ...
                scanFolders(f);
            } else {
                // 输出
                System.out.println(f);
            }
        }
    }
}

输出结果 :
D:\课程资料\1.jpg
D:\课程资料\2.jpg
D:\课程资料\3.jpg
D:\课程资料\BEYOND-不再犹豫.mp3
D:\课程资料\Beyond-冲上云霄.mp3
D:\课程资料\Beyond-曾经拥有.mp3
D:\课程资料\Demo.java
D:\课程资料\folders\1.jpg
D:\课程资料\folders\2.jpg
D:\课程资料\folders\3.jpg

第三章 综合案例

3.1 文件搜索

搜索D:\aaa 目录中的.java 文件。

分析：

1. 目录搜索，无法判断多少级目录，所以使用递归，遍历所有目录。
2. 遍历目录时，获取的子文件，通过文件名称，判断是否符合条件。

代码实现：

import java.io.File;

public class Test5 {
    public static void main(String[] args) {

        // 文件搜索
        File file = new File("D:\\课程资料");

        // 调用方法 :
        searchFile(file);
    }

    public static void searchFile(File file) {
        // 1. 获取文件数组
        File[] files = file.listFiles();
        // 2. 遍历文件数组
        for (File f : files) {
            // 3. 判断当前遍历文件对象是文件还是文件夹
            if (f.isDirectory()) {
                // 3.1 文件夹, 递归遍历
                searchFile(f);
            } else {
                // 3.2 文件对象, 判断是否为指定或后缀名
                if (f.getName().endsWith(".java")) {
                    System.out.println(f);
                }
            }
        }
    }
}

输出结果 :
D:\课程资料\Demo.java
D:\课程资料\folders\Demo.java
D:\课程资料\folders\folder2\Demo.java
D:\课程资料\folders\folder2\HelloWorld.java
D:\课程资料\folders\HelloWorld.java
D:\课程资料\HelloWorld.java
D:\课程资料\HelloWorld3.java
D:\课程资料\HelloWorld5.java
D:\课程资料\HelloWorld6.java
D:\课程资料\HelloWorld7.java
D:\课程资料\HelloWorld8.java

3.2 文件过滤器优化

java.io.FileFilter是一个接口，是File的过滤器。 该接口的对象可以传递给File类的listFiles(FileFilter) 作为参数， 接口中只有一个方法。

boolean accept(File pathname) ：测试pathname是否应该包含在当前File目录中，符合则返回true。

分析：

1. 接口作为参数，需要传递子类对象，重写其中方法。我们选择匿名内部类方式，比较简单。
2. accept方法，参数为File，表示当前File下所有的子文件和子目录。保留住则返回true，过滤掉则返回false。保留规则：
   1. 要么是.java文件。
   2. 要么是目录，用于继续遍历。
3. 通过过滤器的作用，listFiles(FileFilter)返回的数组元素中，子文件对象都是符合条件的，可以直接打印。

代码实现一：

public class MyFileFilter implements FileFilter {
    @Override
    public boolean accept(File pathname) {
        boolean result = pathname.isDirectory() || pathname.getName().endsWith(".java");
        // System.out.println("pathname = " + pathname + ", result = " + result);
        return result;
    }
}

public class Test1 {
    public static void main(String[] args) {

        // 文件搜索
        File file = new File("D:\\课程资料");

        // 调用方法 :
        searchFile(file);
    }

    public static void searchFile(File file) {
        // 1. 获取文件数组, 传递一个文件过滤器对象
        File[] files = file.listFiles(new MyFileFilter());
        for (File f : files) {
            // 判断
            if (f.isDirectory()) {
                searchFile(f);
            } else {
                System.out.println(f);
            }
        }
    }
}

输出结果 :
D:\课程资料\Demo.java
D:\课程资料\folders\Demo.java
D:\课程资料\folders\folder2\Demo.java
D:\课程资料\folders\folder2\HelloWorld.java
D:\课程资料\folders\HelloWorld.java
D:\课程资料\HelloWorld.java
D:\课程资料\HelloWorld3.java
D:\课程资料\HelloWorld5.java
D:\课程资料\HelloWorld6.java
D:\课程资料\HelloWorld7.java
D:\课程资料\HelloWorld8.java

代码实现二 :

import java.io.File;
import java.io.FileFilter;

public class Test1 {
    public static void main(String[] args) {

        // 文件搜索
        File file = new File("D:\\课程资料");

        // 调用方法 :
        searchFile(file);
    }

    public static void searchFile(File file) {
        // 1. 获取文件数组, 传递一个文件过滤器对象
        File[] files = file.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.isDirectory() || pathname.getName().endsWith(".java");
            }
        });
        for (File f : files) {
            // 判断
            if (f.isDirectory()) {
                searchFile(f);
            } else {
                System.out.println(f);
            }
        }
    }
}

输出结果 :
D:\课程资料\Demo.java
D:\课程资料\folders\Demo.java
D:\课程资料\folders\folder2\Demo.java
D:\课程资料\folders\folder2\HelloWorld.java
D:\课程资料\folders\HelloWorld.java
D:\课程资料\HelloWorld.java
D:\课程资料\HelloWorld3.java
D:\课程资料\HelloWorld5.java
D:\课程资料\HelloWorld6.java
D:\课程资料\HelloWorld7.java
D:\课程资料\HelloWorld8.java

3.3 Lambda优化

分析：FileFilter是只有一个方法的接口，因此可以用lambda表达式简写。

lambda格式：

()-> {}

代码实现：

import java.io.File;
import java.io.FileFilter;

public class Test1 {
    public static void main(String[] args) {

        // 文件搜索
        File file = new File("D:\\课程资料");

        // 调用方法 :
        searchFile(file);
    }

    public static void searchFile(File file) {
        // 1. 获取文件数组, 传递一个文件过滤器对象
        File[] files = file.listFiles(f -> f.isDirectory() || f.getName().endsWith(".java"));
        
        for (File f : files) {
            // 判断
            if (f.isDirectory()) {
                searchFile(f);
            } else {
                System.out.println(f);
            }
        }
    }
}

输出结果 :
D:\课程资料\Demo.java
D:\课程资料\folders\Demo.java
D:\课程资料\folders\folder2\Demo.java
D:\课程资料\folders\folder2\HelloWorld.java
D:\课程资料\folders\HelloWorld.java
D:\课程资料\HelloWorld.java
D:\课程资料\HelloWorld3.java
D:\课程资料\HelloWorld5.java
D:\课程资料\HelloWorld6.java
D:\课程资料\HelloWorld7.java
D:\课程资料\HelloWorld8.java

递归累和图解