Java基础：File类、递归

Myth丶恋晨 2024-03-31 17:36 81阅读 0赞

## **第一章 File类** ##

### **1.1 概述** ###

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

### **1.2 构造方法** ###

*  `public File(String pathname)`：通过将给定的**路径名字符串**转换为抽象路径名来创建新的`File`实例。
 *  `public File(String parent, String child)`：从**父路径名字符串和子路径名字符串**创建新的`File`实例。
 *  `public File(File parent, String child)`：从**父抽象路径名和子路径名字符串**创建新的`File`实例。

构造举例，代码如下：

public class File_Demo {
        
        public static void main(String[] args) {
        
            // 文件路径名
            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 child2 = "bbb.txt";
            File file4 = new File(parentDir, child2);
        }
    }

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

### **1.3 常用方法** ###

#### **获取功能的方法** ####

*  `public String getAbsolutePath()`：返回此`File`的绝对路径名字符串。
 *  `public String getPath()`：将此`File`转换为路径名字符串。
 *  `public String getName()`：返回由此`File`表示的文件或目录的名称。
 *  `public long length()`：返回由此`File`表示的文件的长度。

方法演示，代码如下：

public class FileGet_Demo {
        
        public static void main(String[] args) {
        
            File f = new File("D:\\java\\javaCode\\HelloWorld.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:\\java\\javaCode");
            System.out.println("目录绝对路径:"+f2.getAbsolutePath());
            System.out.println("目录构造路径:"+f2.getPath());
            System.out.println("目录名称:"+f2.getName());
            System.out.println("目录长度:"+f2.length());
        }
    }

![在这里插入图片描述][ab86154bb0a242c68c4332368731052a.png_pic_center]

> `API`中说明：`length()`，表示文件的长度。但是`File`对象表示目录，则返回值未指定。
> 
> 由此抽象路径名表示的文件的长度（以字节为单位），如果文件不存在， 0L 。 某些操作系统可能会返回0L用于表示系统依赖实体（如设备或管道）的路径名。

#### **绝对路径和相对路径** ####

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

public class FilePath_Demo {
        
        public static void main(String[] args) {
        
            // D盘下的bbb.java文件
            File f = new File("D:\\java\\javaCode\\FilePath.txt");
            System.out.println(f.getAbsolutePath());
    
            // 项目下的bbb.java文件
            File f2 = new File("FilePath.txt");
            System.out.println(f2.getAbsolutePath());
        }
    }

![在这里插入图片描述][9b9495d4ea914c0da5b7f6b98baea1c6.png_pic_center]

#### **判断功能的方法** ####

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

方法演示，代码如下：

public class FileIs_Demo {
        
        public static void main(String[] args) {
        
            File f = new File("D:\\java\\javaCode\\HelloWorld.java");
            File f2 = new File("D:\\java\\javaCode");
            // 判断是否存在
            System.out.println("D:\\java\\javaCode\\HelloWorld.java 是否存在:"+f.exists());
            System.out.println("D:\\java\\javaCode 是否存在:"+f2.exists());
            // 判断是文件还是目录
            System.out.println("D:\\java\\javaCode 文件?:"+f2.isFile());
            System.out.println("D:\\java\\javaCode 目录?:"+f2.isDirectory());
        }
    }

![在这里插入图片描述][9a105be0d43a4842a858799e89a48954.png_pic_center]

#### **创建删除功能的方法** ####

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

方法演示，代码如下：

public class FileCreateDelete_Demo {
        
        public static void main(String[] args) throws IOException {
        
            // 文件的创建
            File f = new File("D:\\java\\javaCode\\aaa.txt");
            System.out.println("D:\\java\\javaCode\\aaa.txt 是否存在:"+f.exists()); // false
            System.out.println("D:\\java\\javaCode\\aaa.txt 是否创建:"+f.createNewFile()); // true
            System.out.println("D:\\java\\javaCode\\aaa.txt 是否存在:"+f.exists()); // true
    
            // 目录的创建
            File f2= new File("D:\\java\\javaCode\\newDir");
            System.out.println("D:\\java\\javaCode\\newDir 是否存在:"+f2.exists());// false
            System.out.println("D:\\java\\javaCode\\newDir 是否创建:"+f2.mkdir());	// true
            System.out.println("D:\\java\\javaCode\\newDir 是否存在:"+f2.exists());// true
    
            // 创建多级目录
            File f3= new File("D:\\java\\javaCode\\newDira\\newDirb");
            System.out.println("D:\\java\\javaCode\\newDira\\newDirb 是否创建成功:" + f3.mkdir());// false
            File f4= new File("D:\\java\\javaCode\\newDira\\newDirb");
            System.out.println("D:\\java\\javaCode\\newDira\\newDirb 是否创建成功:" + f4.mkdirs());// true
    
            // 文件的删除
            System.out.println(f.delete());// true
    
            // 目录的删除
            System.out.println(f2.delete());// true
            System.out.println(f4.delete());// true 只能删除newDirb， newDira删除不了
        }
    }

![在这里插入图片描述][0e40fdfd9f784f66b448bcbe83b7cd24.png_pic_center]

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

### **1.4 目录的遍历** ###

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

public class FileFor_Demo {
        
        public static void main(String[] args) {
        
            File dir = new File("D:\\java\\javaCode");
            //获取当前目录下的文件以及文件夹的名称。
            String[] names = dir.list();
            for(String name : names){
        
                System.out.println(name);
            }
            System.out.println("--------------------");
            //获取当前目录下的文件以及文件夹对象，只要拿到了文件对象，那么就可以获取更多信息
            File[] files = dir.listFiles();
            for (File file : files) {
        
                System.out.println(file);
            }
        }
    }

![在这里插入图片描述][53c68de555b24d56b23db407645e54f5.png_pic_center]

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

## **第二章 递归** ##

### **2.1 概述** ###

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

*  **递归的分类:**
    
     *  递归分为两种，直接递归和间接递归。
     *  直接递归称为方法自身调用自己。
     *  间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。
 *  **注意事项：**
    
     *  递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
     *  在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
     *  构造方法，禁止递归。

public class Recursion_Demo {
        
        /*
         * 构造方法,禁止递归
         * 编译报错:构造方法是创建对象使用的,不能让对象一直创建下去
         */
        public Recursion_Demo() {
        
            //Recursion_Demo();
        }
    }

public class Recursion_Demo {
        
        public static void main(String[] args) {
        
            a();
        }
        /*
         * 1.递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。 Exception in thread "main"
         * java.lang.StackOverflowError
         */
        private static void a() {
        
            System.out.println("a方法");
            a();
        }
    }

![在这里插入图片描述][172375e3a66c46c2946e067f5d319357.png_pic_center]

public class Recursion_Demo {
        
        public static void main(String[] args) {
        
            b(5001);
        }
    
        /*
         * 2.在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
         * 	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);
        }
    }

![在这里插入图片描述][ba384ec658b44e24b5d0dfaeb1d72728.png_pic_center]

### **2.2 递归累加求和** ###

#### **计算1 ~ n的和** ####

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

**实现代码**：

package com.dcxuexi.java22;
    
    /***
     * @Title DiGuiDemo
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 16:43
     * @Version 1.0.0
     */
    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);
        }
    }

![在这里插入图片描述][3c541671e73c4b7ca9f0c6a738df009e.png_pic_center]

#### **代码执行图解** ####

![在这里插入图片描述][a1a7d7527f89438f8822b9b274314fed.png_pic_center]

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

### **2.3 递归求阶乘** ###

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

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

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

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

**代码实现**：

package com.dcxuexi.java22;
    
    /***
     * @Title DiGuiDemo02
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 16:48
     * @Version 1.0.0
     */
    public class DiGuiDemo02 {
        
        //计算n的阶乘，使用递归完成
        public static void main(String[] args) {
        
            int n = 3;
            // 调用求阶乘的方法
            int value = getValue(n);
            // 输出结果
            System.out.println("阶乘为:"+ value);
        }
        /*
            通过递归算法实现.
            参数列表:int
            返回值类型: int
          */
        public static int getValue(int n) {
        
            // 1的阶乘为1
            if (n == 1) {
        
                return 1;
            }
          	/*
          	  n不为1时,方法返回 n! = n*(n-1)!
              递归调用getValue方法
          	*/
            return n * getValue(n - 1);
        }
    }

![在这里插入图片描述][955947fd752c40f084dec4b000dac7bd.png_pic_center]

### **2.4 递归打印多级目录** ###

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

**代码实现**：

package com.dcxuexi.java22;
    
    import java.io.File;
    
    /***
     * @Title DiGuiDemo03
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 16:49
     * @Version 1.0.0
     */
    public class DiGuiDemo03 {
        
        public static void main(String[] args) {
        
            // 创建File对象
            File dir  = new File("D:\\java\\javaCode");
            // 调用打印目录方法
            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);
                }
            }
        }
    }

![在这里插入图片描述][72d994f0d52244fea1eedacd77c160c3.png_pic_center]

## **第三章 综合案例** ##

### **3.1 文件搜索** ###

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

分析：

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

代码实现：

package com.dcxuexi.java22;
    
    import java.io.File;
    
    /***
     * @Title DiGuiDemo04
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 16:53
     * @Version 1.0.0
     */
    public class DiGuiDemo04 {
        
        public static void main(String[] args) {
        
            // 创建File对象
            File dir  = new File("D:\\java\\javaCode");
            // 调用打印目录方法
            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);
                }
            }
        }
    }

![在这里插入图片描述][fbfcf9160dfb4e45a78cf0c1062c002c.png_pic_center]

### **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)`返回的数组元素中，子文件对象都是符合条件的，可以直接打印。

代码实现：

package com.dcxuexi.java22;
    
    import java.io.File;
    import java.io.FileFilter;
    
    /***
     * @Title DiGuiDemo05
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 16:57
     * @Version 1.0.0
     */
    public class DiGuiDemo05 {
        
        public static void main(String[] args) {
        
            File dir = new File("D:\\java\\javaCode");
            printDir2(dir);
        }
    
        public static void printDir2(File dir) {
        
            // 匿名内部类方式,创建过滤器子类对象
            File[] files = dir.listFiles(new FileFilter() {
        
                @Override
                public boolean accept(File pathname) {
        
                    return pathname.getName().endsWith(".java")||pathname.isDirectory();
                }
            });
            // 循环打印
            for (File file : files) {
        
                if (file.isFile()) {
        
                    System.out.println("文件名:" + file.getAbsolutePath());
                } else {
        
                    printDir2(file);
                }
            }
        }
    }

![在这里插入图片描述][bddaac08f87f47c4be7c85a0b94e3c9a.png_pic_center]

### **3.3 `Lambda`优化** ###

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

`lambda`格式：

()->{
         }

**代码实现**：

package com.dcxuexi.java22;
    
    import java.io.File;
    import java.io.FileFilter;
    
    /***
     * @Title DiGuiDemo06
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/11 17:02
     * @Version 1.0.0
     */
    public class DiGuiDemo06 {
        
        public static void main(String[] args) {
        
            File dir = new File("D:\\java\\javaCode");
            printDir3(dir);
        }
    
        public static void printDir3(File dir) {
        
            // lambda的改写
            File[] files = dir.listFiles(f ->{
        
                return f.getName().endsWith(".java") || f.isDirectory();
            });
    
            // 循环打印
            for (File file : files) {
        
                if (file.isFile()) {
        
                    System.out.println("文件名:" + file.getAbsolutePath());
                } else {
        
                    printDir3(file);
                }
            }
        }
    }

![在这里插入图片描述][4bb673e3569549cc8a699c4af214ff99.png_pic_center]

[ab86154bb0a242c68c4332368731052a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/2ce3e74b9ac34035849263309ea79658.png
[9b9495d4ea914c0da5b7f6b98baea1c6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/4a45e45952864274bbc958c9fa3bc450.png
[9a105be0d43a4842a858799e89a48954.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/64fce8dd346a4ff8aadb6677091b508f.png
[0e40fdfd9f784f66b448bcbe83b7cd24.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/bfdd44d2f43c4469ab2e3c1484936f9a.png
[53c68de555b24d56b23db407645e54f5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/ffc8279125954ed2b76d627ca16e8707.png
[172375e3a66c46c2946e067f5d319357.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/3ae3d1551d924c748edb8f0eae148234.png
[ba384ec658b44e24b5d0dfaeb1d72728.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/49e69c24f3164d38815601bae22d3dfd.png
[3c541671e73c4b7ca9f0c6a738df009e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/e08904632d7246ac933d920534362caf.png
[a1a7d7527f89438f8822b9b274314fed.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/aa1b8d09986d44ac940cf122805fd176.png
[955947fd752c40f084dec4b000dac7bd.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/889530f94ad944a8820663e6d21e0234.png
[72d994f0d52244fea1eedacd77c160c3.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/f830a15db0c34befa334c4954c523609.png
[fbfcf9160dfb4e45a78cf0c1062c002c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/5db37c660cb74ab4b74a0741c1650e83.png
[bddaac08f87f47c4be7c85a0b94e3c9a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/af329dbb5e43480d9290e00baea14a0c.png
[4bb673e3569549cc8a699c4af214ff99.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/c5c869f409474134874cf104273eae14.png