File、递归

递归

概述

　　递归：

　　指在当前方法内调用自己的这种现象

public class diGui {
    public static void main(String[] args) {
        a();
    }
    private static void a() {
        a();//自己调用自己
    }
}

　　递归的分类：

　　直接递归：方法自身调用自己

package day09;

public class diGui {
    public static void main(String[] args) {
        a();
    }

    private static void a() {
        //没有条件限制 报出java.lang.StackOverflowError
        System.out.println("直接递归");
        a();
    }
}

直接递归

　　间接递归：A方法调用B方法，B方法调用C方法，C方法调用A方法

package day09;

public class diGui {
    public static void main(String[] args) {
        a();
    }

    private static void a() {
        System.out.println("间接递归");
        b();
    }

    private static void b() {
        c();
    }

    private static void c() {
        a();
    }

}

间接递归

　　注意事项：

　　递归一定要有条件限制，保证递归能够停下来，否则会发生栈内存溢出

package day09;

public class diGui {
    public static void main(String[] args) {
        a();
    }

    private static void a() {
        //没有条件限制 报出java.lang.StackOverflowError
        System.out.println("直接递归");
        a();
    }
}

无条件限制栈内存溢出

　　在递归中虽然有限制条件，但是递归次数不能太多，否则也会发生栈内存溢出

package day09;

public class diGui {
    public static void main(String[] args) {
//        a();
        b(1);
/**递归b，第5518次 抛出栈内存溢出
 Exception in thread "main" java.lang.StackOverflowError
 */
    }

    private static void b(int i) {
        System.out.println("递归b，第"+i+"次");
        if(i==10000){
            return;
        }
        i++;
        b(i);
    }

    private static void a() {
        //没有条件限制 报出java.lang.StackOverflowError
        System.out.println("直接递归");
        a();
    }
}

递归次数过多

　　构造方法禁止递归，因为构造方法是用来创建对象的，如果递归的话会产生无数个对象

递归累加求和

　　计算1~n的和

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

　　实现代码：

package day09;

public class demo {
    //计算1~n的和
    public static void main(String[] args) {
        int i = 100;
        System.out.println(sum(i));
    }

    private static int sum(int n) {
        if(n==1){
            return 1;
        }
       return n +sum(n-1);
    }
}

n+(n-1)+(n-2)...+1

递归求阶乘

package day09;

public class demo01 {
    public static void main(String[] args) {
        int num = 5;
        int i = jieCheng(num);
        System.out.println(i);
    }

    private static int jieCheng(int n) {
        if(n ==1){
            return 1;
        }
        return n *jieCheng(n-1);
    }
}

n*(n-1)*(n-2)*...*1

递归打印多级目录

package day09;

import java.io.File;

public class demo02 {
    public static void main(String[] args) {
        //创建File对象
        File file = new File("C:\\Users\\YIAN\\Desktop\\File");
        printDir(file);
    }

    private static void printDir(File file) {
        //获取目录
        File[] files = file.listFiles();
        for (File f:files
             ) {
            //判断是文件还是文件夹
            if(f.isFile()){
                System.out.println("文件名："+f.getAbsolutePath());
            }else {
                System.out.println("文件夹："+f.getAbsolutePath());
                //继续递归
                printDir(f);
            }
        }
    }
}
/**
 * 文件名：C:\Users\YIAN\Desktop\File\1.txt
 * 文件名：C:\Users\YIAN\Desktop\File\directory
 * 文件夹：C:\Users\YIAN\Desktop\File\file1_1
 * 文件名：C:\Users\YIAN\Desktop\File\file1_1\1.txt
 * 文件名：C:\Users\YIAN\Desktop\File\task.txt
 */

File递归文件夹

综合案例

文件搜索

　　需求：　　

　　搜索File目录中的.java文件

　　分析：

　　1、目录搜索，无法判断多少级目录，所以使用递归，遍历所有目录

　　2、遍历目录时，获取子文件，通过文件名称，判断是否符合条件

package day09;

import java.io.File;

public class demo03 {
    public static void main(String[] args) {
        //创建File对象
        File file = new File("C:\\Users\\YIAN\\Desktop\\File");
        //调用getJava方法
        getJava(file);
    }

    private static void getJava(File file) {
        //遍历目录
        File[] files = file.listFiles();
        for (File f:files
             ) {
            //判断是否是文件
            if(f.isFile()){
                //判断是否以.java结尾
                if(f.toString().endsWith(".java")){
                    System.out.println("文件名："+f.getAbsolutePath());
                }
            }else {
                //是文件夹 继续遍历
                getJava(f);
            }
        }
    }
}
/**
 * 文件名：C:\Users\YIAN\Desktop\File\demo.java
 * 文件名：C:\Users\YIAN\Desktop\File\demo01.java
 * 文件名：C:\Users\YIAN\Desktop\File\file1_1\demo02.java
 * 文件名：C:\Users\YIAN\Desktop\File\file1_1\diGui.java
 */

search File

文件过滤器优化

　　概述：

　　java.io.FileFilter 是一个接口，是File的过滤器。

　　作用：

　　用来过滤文件(File对象)

　　抽象方法：

　　boolean accept(File pathname)：测试指定抽象路径名是否包含在某个路径名列表中。

　　boolean accept(File pathname,String name)：测试指定文件是否应该包含在某一文件列表中。

　　参数：

　　File pathname：使用listFiles方法变量目录，得到每一个文件对象

　　String name：使用ListFiles方法遍历目录，获取每一个文件名/文件夹名

　　注意：

　　两个过滤器接口，没有实现类，需要我们自己写实现类，重写过滤的方法

　　代码实现：

　　//自己写实现类，重写过滤方法

package day09;

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

public class FileFilterImlp implements FileFilter {
    //重写accpect方法
    @Override
    public boolean accept(File pathname) {
        //如果pathname是文件夹 也返回true 以继续遍历
        if(pathname.isDirectory()){
            return true;
        }
        //如果以.java结尾 也返回true
        if(pathname.toString().endsWith(".java")){
            return true;
        }
        return false;
    }
}

FileFilterImlp

package day09;

import java.io.File;

public class demo04 {
    public static void main(String[] args) {
        //创建File对象
        File file = new File("C:\\Users\\YIAN\\Desktop\\File");
        //调用getJava方法
        getJava(file);
    }

    private static void getJava(File file) {
        //遍历目录
        File[] files = file.listFiles(new FileFilterImlp());//传递过滤器对象
        for (File f:files
                ) {
            //判断是否是文件
            if(f.isFile()){
                //判断是否以.java结尾
                if(f.toString().endsWith(".java")){
                    System.out.println("文件名："+f.getAbsolutePath());
                }
            }else {
                //是文件夹 继续遍历
                getJava(f);
            }
        }
    }
}

传递过滤器对象

　　再次优化：

package day09;

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

public class demo05 {
    public static void main(String[] args) {
        //创建File对象
        File file = new File("C:\\Users\\YIAN\\Desktop\\File");
        //调用getJava方法
        getJava(file);
    }

    private static void getJava(File file) {
        //传递过滤器对象 使用匿名内部类
        File[] files = file.listFiles(new FileFilter(){
            //重写accept抽象方法
            @Override
            public boolean accept(File pathname) {
                if(pathname.isDirectory()){
                    return true;
                }
                if(pathname.toString().endsWith(".java")){
                    return true;
                }
                return false;
            }
        });
        for (File f:files
                ) {
            //判断是否是文件
            if(f.isFile()){
                //判断是否以.java结尾
                if(f.toString().endsWith(".java")){
                    System.out.println("文件名："+f.getAbsolutePath());
                }
            }else {
                //是文件夹 继续遍历
                getJava(f);
            }
        }
    }
}

使用匿名内部类实现accept()

流程图：

boolean accept(File pathname,String name)：

package day09;

import java.io.File;
import java.io.FilenameFilter;

public class demo06 {
    public static void main(String[] args) {
        //创建File对象
        File file = new File("C:\\Users\\YIAN\\Desktop\\File");
        //调用getJava方法
        getJava(file);
    }

    private static void getJava(File file) {
        //传递过滤器对象 匿名内部类
        File[] files = file.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                if(dir.isDirectory()){
                    return true;
                }
                if(name.endsWith(".java")){
                    return true;
                }
                return false;
            }
        });
        for (File f:files
                ) {
            //判断是否是文件
            if(f.isFile()){
                //判断是否以.java结尾
                if(f.toString().endsWith(".java")){
                    System.out.println("文件名："+f.getAbsolutePath());
                }
            }else {
                //是文件夹 继续遍历
                getJava(f);
            }
        }
    }
}

new FilenameFilter() {}

Lambda优化

package day09;

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

public class demo07 {
    public static void main(String[] args) {
        //创建File对象
        File file = new File("C:\\Users\\YIAN\\Desktop\\File");
        //调用getJava方法
        getJava(file);
    }

    private static void getJava(File file) {
        //传递过滤器对象 Lambda简化
        File[] files = file.listFiles(f->{
            return f.getName().endsWith(".java") || f.isDirectory();
        });
        for (File f:files
                ) {
            //判断是否是文件
            if(f.isFile()){
                System.out.println(f.getAbsolutePath());
            }else {
                //是文件夹 继续遍历
                getJava(f);
            }
        }
    }
}

Lambda简化

posted @ 2021-03-29 22:37 心岛未晴阅读(67) 评论(0) 收藏举报

刷新页面返回顶部

心岛未晴

好风凭借力，送我上青云