java 递归

一 递归的概述

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

public void method(){
    System.out.println(“递归的演示”);
    //在当前方法内调用自己
    method();
}

　　递归分为两种，直接递归和间接递归。

　　直接递归称为方法自身调用自己。间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。

　　递归的代码演示，计算1-n之间的和，使用递归完成

public class DiGuiDemo {
    public static void main(String[] args) {
        //计算1~num的和，使用递归完成
        int n = 5;
        int sum = getSum(n);
        System.out.println(sum);
        
    }
    public static int getSum(int n) {
        if(n == 1){
            return 1;
        }
        return n + getSum(n-1);
    }
}

 代码执行流程图解

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

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

二 递归打印所有子目录中的文件路径

编写一个方法用来打印指定目录中的文件路径，并进行方法的调用

要求：若指定的目录有子目录，那么把子目录中的文件路径也打印出来

步骤：

1. 指定要打印的目录File对象

2. 调用getFileAll()方法

2.1 获取指定目录中的所有File对象

2.2 遍历得到每一个File对象

2.3 判断当前File 对象是否是目录

判断结果为true，说明为目录，通过递归，再次调用步骤2的getFileAll()方法

判断结果为false，说明是文件，打印文件的路径

public class FileDemo2 {
    public static void main(String[] args) {
        File file = new File("d:\test");
        getFileAll(file);
    }
    //获取指定目录以及子目录中的所有的文件
    public static void getFileAll(File file) {
        File[] files = file.listFiles();
        //遍历当前目录下的所有文件和文件夹
        for (File f : files) {
            //判断当前遍历到的是否为目录
            if(f.isDirectory()){
                //是目录，继续获取这个目录下的所有文件和文件夹
                getFileAll(f);
            }else{
                //不是目录，说明当前f就是文件，那么就打印出来
                System.out.println(f);
            }
        }
    }
}

三 搜索指定目录中的.java文件(含子目录)

需求：打印指定目录即所有子目录中的.java文件的文件路径

要求：编写一个方法用来打印指定目录中的.java文件路径，并进行方法的调用

若指定的目录有子目录，那么把子目录中的.java文件路径也打印出来

步骤：

1. 指定要打印的目录File对象

2. 调用getFileAll()方法，传入要打印的目录File对象

2.1 通过FilenameFilter过滤器获取指定目录中的所有.java类型的File对象

2.2 遍历得到每一个File对象

2.3 判断当前File 对象是否是目录

判断结果为true，说明为目录，通过递归，再次调用步骤2的getFileAll()方法

判断结果为false，说明是文件，打印文件的路径

测试类

public class Demo05 {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\io0512");
        gettxtjava(file);
    }
    public static void gettxtjava(File file){
        File[] files =  file.listFiles(new MyFilter());
        for (File f: files) {
            if(f.isDirectory()){
                gettxtjava(f);
            }else{    
                    System.out.println(f);        
            }
        }
    }
}

自定类继承FilenameFilter过滤器接口

public class MyFilter implements FileFilter {
    @Override
    public boolean accept(File pathname) {
        boolean b =false;        
        
        if(pathname.getName().toLowerCase().endsWith(".java")){
            b= true;
        }
        if(pathname.isDirectory()){
            b= true;
        }
        return b;
    }    
}    

四 用递归做斐波那契数列

题目：最开始有一对兔子，兔子在第三个月及之后的每个月会生一对小兔子，小兔子第三个月及之后每个月也会生一对小兔子

求一对小兔子在12个月之后有多少对小兔子

public class Demo02 {
    public static void main(String[] args) {
    System.out.println(tuzi(12));
        }
    }

public static int tuzi(int a){
        if(a==1){
            return 1;
        }
        if(a==2){
            return 1;
        }
        return tuzi(a-2)+tuzi(a-1);
    }

五 数组冒泡排序

public class Demo02 {
    public static void main(String[] args) {
        int[] a = {12,1,25,30,25,100,8,35,47,99,11,4};
        get(a);
        for (int i : a) {
            System.out.println(i);
        }
    }
}

public static void get(int[] a){
        int n = 0;
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j < a.length-i-1; j++) {
                if(a[j]>a[j+1]){
                    n = a[j];
                    a[j] = a[j+1];
                    a[j+1]=n;
                }
            }
        }
    }

六 数组快速排序

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {12,10,5,25,35,99,1,4,100,78,89,98,3,55};
        QuickS(arr, 0, arr.length-1);
        for (int i : arr) {
            System.out.print(i+"...");
        }
        
    }
    //快速排序
    public static int[]  QuickS(int[] arr,int start,int end){
        int key = arr[start];
        int i = start;
        int j = end;
        while(i<j){
            while(arr[i]<key&&i<j){
                i++;
            }
            while(arr[j]>key&&i<j){
                j--;
            }
            if(arr[i]==arr[j]&&i<j){
                i++;
                j--;
            }else{
                int num = arr[i];
                arr[i] = arr[j];
                arr[j] = num;
            }
        }
        if(i-1>start){
            arr = QuickS(arr,start,i-1);
        }
        if(j+1<end){
            arr = QuickS(arr,j+1,end);
        }
        return arr;
    }
    }

七 搜索指定目录中的.java文件(含子目录)工具类

public class FileFindTool {
    public static List<File> getfiles(File file,String[] filetype){
        //用来存储目录
        List<File> list = new ArrayList<File>();
        File[] files = file.listFiles(new MyFilter(filetype));
        for (File f : files) {
            //当文件类型为文件夹时
            if(f.isDirectory()){
                //接收返回的list 并添加到总的list里
                for (File file2 : getfiles(f, filetype)) {
                    list.add(file2);
                }
            }else{
                //当文件不为文件夹时
                        list.add(f);                
                }
            }
        return list;
    }        
}

public class MyFilter implements FileFilter {
    private String[] filetype ;
    //写个构造方法用来存储字符串数组
    public MyFilter(String[] filetype){
        this.filetype = filetype;
    }
    public MyFilter(){
    
    }
    public boolean accept(File pathname) {
        boolean b =false;        
        for (String s : filetype) {
            if(pathname.getName().toLowerCase().endsWith(s)){
                b=true;
            }
        }
        if(pathname.isDirectory()){
            b= true;
        }
        return b;
    }    
}