递归

所谓递归，就是方法调用自身。对于递归来说，一定有一个出口，让递归结束。只有这样才能保证不出现死循环。举几个简单的例子说明。

1、使用递归计算阶乘

public class Test
{
    //使用递归计算阶乘
    public static int  compute2(int number)
    {
        //方法的出口
        if (number == 1)
        {
            return 1;
        }
        else 
        {
            return number * compute2(number - 1);
        }
    }
    public static void main(String[] args)
    {
        System.out.println(compute2(5));
    }
}

2、使用递归计算斐波那契数列

public class Fab
{
    //使用递归计算斐波那契数列
    public int compute(int n)
    {
        //出口
        if(n == 1 || n == 2)
            return 1;
        else
        {
            return compute(n -1) + compute(n - 2);
        }
    }
    
    public static void main(String[] args)
    {
        Fab fab = new Fab();
        
        System.out.println(fab.compute(9));
    }
}

3、使用递归删除某个目录，及其中下所有文件

public class FileTest9
{
    public void deleteAll(File file)
    {
        /**
         * 出口
         * 或者file是一个文件
         * 或者file是一个空目录
         */
        if (file.isFile() || file.list().length == 0)
        {
            file.delete();
        }
        //删除子目录中的文件
        else 
        {
            File[] files = file.listFiles();
            for(File f : files)
            {
                deleteAll(f);
                f.delete();
            }
        }
    }
    
    public static void main(String[] args)
    {
        FileTest9 fileTest9 = new FileTest9();
        
        File file = new File("e:/io/xyz");
        
        fileTest9.deleteAll(file);
    }
}

4、给定任意一个目录，以树形方式展现出该目录中的所有子目录和文件。另外，在展现的时候将目录排在上面，文件排在下面。每一层要加上缩进。

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class ListAllFiles
{
    //用来存放目录或文件所处的层次
    private static int times = 0;
    
    
    public static void main(String[] args)
    {
        File file = new File("F:\\Code\\Qt");
        deepList(file);
    }
    
    
            
    public static void deepList(File file)
    {
        //递归出口
        if (file.isFile() || file.listFiles().length == 0)
        {
            return;
        }
        else
        {
            File[] files = file.listFiles();
            //对files数组进行排序，使目录位于文件前面
            files = sortedFiles(files);
            
            for(File f: files)
            {
                //用来存放输出结果
                StringBuffer output = new StringBuffer();
                if (f.isFile())
                {
                    output.append(getTabs(times));
                    output.append(f.getName());
                }
                else
                {
                    output.append(getTabs(times));
                    output.append(f.getName());
                    output.append("\\");
                }
                System.out.println(output);
                
                if (f.isDirectory())
                {
                    times++;
                    deepList(f);
                    times--;
                }
            }
        }
    }
    

    //返回排完序的File数组
    public static File[] sortedFiles(File[] files)
    {
        List<File> dirList = new ArrayList<>();
        List<File> fileList = new ArrayList<>();
        
        for(File f : files)
        {
            if (f.isDirectory())
            {
                dirList.add(f);
            }
            else
            {
                fileList.add(f);
            }
        }
        dirList.addAll(fileList);
        
        return dirList.toArray(new File[files.length]);
        
    }

    //返回一个包含若干个tab键的字符串
    public static String getTabs(int times)
    {
        StringBuffer buffer = new StringBuffer();
        
        for (int i = 0; i < times; i++)
        {
            buffer.append("\t");
        }
        
        return buffer.toString();
    }
}

上一篇：io——File类
下一篇：装饰模式（Decrator）