java基础学习-File类-递归

File类-递归

递归：指在当前方法内调用自己的这种现象。
递归的思想：把一个大问题分成一个一个的小问题，解决每一个小问题，来实现 大问题的解决
递归的分类:
直接递归：方法自身调用自己。
间接递归：比如A方法调用B方法，B方法调用其他方法，调用几次其他方法之后最后又开始调用A方法。
注意事项：
递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
/用递归的方法求[n-m]之和，和[n-m]之间数的乘积/

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

        int i = numSum(1, 10);
        System.out.println(i);
        int r = numChen(1, 4);
        System.out.println(r);
    }

    //和；奇数；偶数；倍数等只需要改else里面的代码
    public static int numSum(int start, int end) {    //和
        if (start == end) {
            return start;
        } else {
            return end + numSum(start, end - 1);
        }
    }

    public static int numChen(int start, int end) {    //阶乘
        if (start == end) {
            return start;
        } else {
            return end * numChen(start, end - 1);
        }
    }
}

使用递归对文件夹进行操作：
当我们要对一个文件进行遍历获取整个文件；删除整个文件夹等这些操作时，为了解决问题常常用到递归。

获取每一层文件夹和文件的名字：

public class FileTest {
    public static void main(String[] args) {
        File file = new File("F:\\abc");  //f盘下建的多级文件夹

        pnAllFileName(file);
    }

    /*遍历文件夹下面的文件：
    * 首先判断传过来的是文件还是文件夹
    * if（文件夹）{
    *   把这个文件夹下面的所有文件放到一个数组中
    *   挨个判断这个数组中的每一个文件
    *   调用该方法来解决每一个数组中的元素判断的问题 
    * }else{
    *   直接输出名字
    * }

    * */
       //递归的方法调用打印每一层文件和目录的名字
    public static void pnAllFileName(File file) {

        if (file.isDirectory()) {
            System.out.println(file.getName() + ":");

            File[] files = file.listFiles();
            for (int i = 0; i < files.length; i++) {
                pnAllFileName(files[i]);  //调用这个方法实现子文件
            }

        } else {

            System.out.println(file.getName());
        }
    }
}

删除一整个文件夹：

public class Tets8_5 {
    public static void main(String[] args) {
        File file = new File("D:\\abc");
        deleteFileAll(file);

    }

    public static void deleteFileAll(File file) {
        if (!file.isDirectory()) {
            System.out.println("删除的文件为：" + file.getName() + "->" + file.delete());
        } else {

            File[] files = file.listFiles();
            for (File file1 : files) {
                deleteFileAll(file1);
            }
            if (file.exists())    //删除目录
                System.out.println("删除的文件为：" + file.getName() + "->" + file.delete());
        }
    }
}

文件过滤器
java.io.FileFilter 是一个接口，是File的过滤器。 该接口的对象可以传递给File类的 listFiles(FileFilter) 作为参数， 接口中只有一个方法。
boolean accept(File pathname) ：测试pathname是否应该包含在当前File目录中，符合则返回true。
分析：
接口作为参数，需要传递子类对象，重写其中方法。我们选择匿名内部类方式或者实现类的方式都可以。
2. accept 方法，参数为File，表示当前File下所有的子文件和子目录。保留住则返回true，过滤掉则返回 false。保留规则：
1. 要么是.txt文件。
2. 要么是目录，用于继续遍历。
3. 通过过滤器的作用，listFiles(FileFilter) 返回的数组元素中，子文件对象都是符合条件的，可以直接打印。

使用匿名内部类的方式实现

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

public class TestFileFilter {
    public static void main(String[] args) {
        File file = new File("D:\\abc");
        fileFilterTest1(file);
    }

    /**
     * 把这个文件下的所有文件、文件夹用过滤器处理，处理后的结果放在数组中
     * File[] listFiles(FileFilter filter)
     * 返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
     * File[] listFiles(FilenameFilter filter)
     * 返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
     */
    public static void fileFilterTest1(File file) {      //只能完成一层过滤

        File[] files = file.listFiles(new FileFilter() {   //这个括号中的代码块都是在判断同一级中的文件
            @Override
            public boolean accept(File pathname) {
                if (pathname.isDirectory()) {         //判断是文件还是文件夹
                    return true;
                } else {
                    if (pathname.getName().endsWith(".txt")) {  //判断是否为".txt"结尾
                        return true;
                    } else {
                        return false;
                    }
                }
            }
        });

        for (File file1 : files) {          //遍历数组中文件和文件夹
            if (file1.isDirectory()) {      //如果是文件夹对这个文件夹执行相同的操作
                fileFilterTest1(file1);

            } else {                        //如果是文件一定是符合要求的直接输出名字即可
                System.out.println(file1.getName());
            }

        }
    }
}

使用FileFilter实现类的方式实现：
实现FileFilter接口：

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

public class MyFileFilter implements FileFilter {
    @Override
    public boolean accept(File pathname) {
        return pathname.getName().endsWith(".java") || pathname.isDirectory();
        /*String name=pathname.getName();
        if (pathname.isDirectory()){
          return true;
        }else {
            if(name.endsWith(".java")){
                return  true;
            }else {
                return false;
            }
        }
        */
    }
}

测试类

import java.io.File;
/*D:\IdeaProjects --测试文件位置*/

public class test {
    public static void main(String[] args) {
        File file= new File("D:\\IdeaProjects");
        pnAllTxt(file);
    }
    public static void pnAllTxt(File f){

        if (f.isDirectory()){
            File[] files = f.listFiles(new MyFileFilter());
            for (File file : files) {
                pnAllTxt(file);
            }

        }else {
            System.out.println(f);
        }
    }
}