File类、递归、文件搜索、文件过滤器优化、Lambda优化

1.1 概述：

递归的概念：方法自身调用自身则称为递归。

递归的分类：

间接递归：方法A调用方法B，方法B调用方法C，方法C调用方法A（在实际开发过程中一般不用）

直接递归：方法A调用方法A

递归的注意事项：

递归一定要出现出口：结束递归的条件。

递归次数不要太多。

java.lang.StackOverflowError:栈内存溢出错误

1.2 递归求1-n的和：

/*
    递归求和：求1-n的和,假设n=5
    sum(5)=1+2+3+4+5=sum(4)+5
    sum(4)=1+2+3+4=sum(3)+4
    sum(3)=1+2+3=sum(2)+3
    sum(2)=1+2=sum(1)+2
    sum(1)=1

    当n>1时，
    sum(n)=sum(n-1)+n;
    当n==1时，sum(1)=1

 */
public class DGDemo01 {
    public static void main(String[] args) {
        System.out.println(sum(1));
        System.out.println(sum(5));
    }
    public static int sum(int n){
        if(n == 1) return 1;
        return sum(n-1)+n;
    }
}

1.3 递归求n的阶层：

/*
    递归求n! : 阶层
    n=5   1*2*3*4*5
    jc(5)=1*2*3*4*5=jc(4)*5
    jc(4)=1*2*3*4=jc(3)*4
    jc(3)=1*2*3=jc(2)*3
    jc(2)=1*2=jc(1)*2
    jc(1)=1

    当n>1时，
    jc(n)=jc(n-1)*n
    当n==1时，jc(1)=1
*/
public class DGDemo01 {
    public static void main(String[] args) {
        System.out.println(jc(1));
        System.out.println(jc(5));
    }
    public static int jc(int n){
        if(n == 1) return 1;
        return jc(n-1)*n;
    }
}

1.4 递归打印多层目录：

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

下列代码中：else {
//file是文件夹
printFile(file);
}

当file是文件夹时，就继续调用此方法，即使用了递归。

import java.io.File;
/*
    打印指定文件夹下所有文件名
 */
public class DGDemo02 {
    public static void main(String[] args) {
        File f=new File("E:\\Adobe Photoshop CC 2017 SP");
        printFile(f);
    }
    /*
        打印指定文件夹下的所有文件名
     */
    public static void printFile(File dir){
        //获取文件夹下的所有文件，返回数组
        File[] files = dir.listFiles();
        //遍历文件数组
        for(File file:files){
            //判断是否是普通文件
            if(file.isFile()){
                System.out.println(file.getName());
            }else {
                //file是文件夹
                printFile(file);
            }
        }
    }
}

1.5 获得指定文件夹的大小：

import java.io.File;

public class DGDemo03 {
    static long size =  0;
    public static void main(String[] args) {
        File f=new File("D:\\暴风影音");
        getdirLength(f);
        System.out.println("size="+size);//size=237375371
    }
    /*
        获得指定文件夹的大小
     */
    public static void getdirLength(File dir){
        //获取文件夹下的所有文件，返回文件数组
        File[] files = dir.listFiles();
        //遍历数组
        for(File file:files){
            //判断是否是普通文件
            if(file.isFile()){
                size += file.length();
            }else {
                getdirLength(file);
            }
        }

    }
}

1.6 打印指定文件夹下所有的pak文件(.pak结尾)：

方式1：

import java.io.File;

/*
    打印指定文件夹下所有的pak文件(.pak结尾)
 */
public class DGDemo04 {
    public static void main(String[] args) {
        //创建文件对象并关联目标文件夹
        File f=new File("D:\\暴风影音\\locales");
        printFileName(f);
    }
    /*
        打印指定文件夹下的pak文件
     */
    public static void printFileName(File dir){
        //获得文件夹下的所有文件，返回文件数组
        File[] files = dir.listFiles();

        //遍历文件数组
        for(File file:files){
            //判断是否是普通文件
            if(file.isFile()){
                //判断是否是以.pak结尾
                if(file.getName().endsWith(".pak")){
                    System.out.println(file.getName());
                }else {
                    printFileName(file);
                }
            }
        }
    }
}

方式2：使用 .切割文件名的方式：

切割注意:一定要在.前面加上\\ 因为.在正则表达式中是一个通配符，可以匹配任意的字符，每个字符进行切割，把字符串切没了，加上\\之后对.进行转意，使之变成普通的点。

import java.io.File;

/*
    打印指定文件夹下所有的pak文件(.pak结尾)
 */
public class DGDemo04 {
    public static void main(String[] args) {
        //创建文件对象并关联目标文件夹
        File f=new File("D:\\暴风影音\\locales");
        printFileName(f);
    }
    /*
        打印指定文件夹下的pak文件
     */
    public static void printFileName(File dir){
        //获得文件夹下的所有文件，返回文件数组
        File[] files = dir.listFiles();

        //遍历文件数组
        for(File file:files){
            //判断是否是普通文件
            if(file.isFile()){
                //获得文件名
                String fileName = file.getName();
                //使用.切割文件名
                // .在正则表达式中是一个通配符，可以匹配任意的字符，所有本题中需要在.前面加上“\\.”
                String[] strs = fileName.split("\\.");
                //获得文件名后缀
                String extName = strs[1];
                //判断是否.pak结尾
                if(extName.equals("pak")){
                    System.out.println(file.getName());
                }else {
                    printFileName(file);
                }

            }
        }
    }
}

ps:额外补充类似点切割的例子：

public class DGDemo04 {
    public static void main(String[] args) {
        String ip="192.168.23.11";
        String[] ips=ip.split("\\.");
        System.out.println(Arrays.toString(ips));
     }
}

2.1 文件过滤器优化（推荐使用，效率更高）：

File类与文件过滤器相关的方法：

File[] listFiles(FileFilter fileFilter);根据指定的文件过滤器获得文件

FileFilter接口概述：只要实现了该接口的对象就是一个文件过滤器对象。

重写accept方法的调用时机：

当系统内部获得到文件夹下的每一个文件或子文件夹时，都会将其封装成文件对象传递给accept方法

accept方法返回值的作用：

true：接受该文件，不过滤该文件

false：不接受该文件，过滤掉该文件

import java.io.File;
import java.io.FileFilter;
/*
    自定义过滤器
 */
public class MyFilefilter implements FileFilter {
    @Override
    public boolean accept(File pathname) {
        if(pathname.isDirectory() || pathname.getName().endsWith(".pak")){
            //返回true表示不过滤文件
            return true;
        }else {
            return false;
        }
    }
}




import java.io.File;

public class DGDemo04 {
    public static void main(String[] args) {
        File f=new File("D:\\\\暴风影音\\\\locales");
        printFile(f);
    }
    public static void printFile(File dir){
        //创建文件过滤器对象
        MyFilefilter myFilefilter = new MyFilefilter();
        //获取文件夹下的所有文件，并返回字符数组
        File[] files = dir.listFiles(myFilefilter);

        //遍历数组
        for(File file:files){
            //判断是否是普通文件
            if(file.isFile()){
                    System.out.println(file.getName());
                }else {
                    printFile(file);
                }
            }
        }
}

2.2 Lambda优化：

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

lambda格式：（）->{}

2.2.1使用匿名内部类简化(直接new FileFilter)

//获取文件夹下的所有文件，并返回字符数组，使用匿名内部类获得文件过滤器对象
File[] files = dir.listFiles(new FileFilter(){......});

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

public class DGDemo04 {
    public static void main(String[] args) {
        File f=new File("D:\\\\暴风影音\\\\locales");
        printFile(f);
    }
    public static void printFile(File dir){
        //获取文件夹下的所有文件，并返回字符数组，使用匿名内部类获得文件过滤器对象
        File[] files = dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if(pathname.isDirectory() || pathname.getName().endsWith(".pak")){
                    //返回true表示不过滤文件
                    return true;
                }
                return false;
            }
        });

        //遍历数组
        for(File file:files){
            //判断是否是普通文件
            if(file.isFile()){
                    System.out.println(file.getName());
                }else {
                    printFile(file);
                }
            }
        }
}

2.2.2 匿名内部类转为Lambda表达式优化

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

public class DGDemo04 {
    public static void main(String[] args) {
        File f=new File("D:\\\\暴风影音\\\\locales");
        printFile(f);
    }
    public static void printFile(File dir){
        //获取文件夹下的所有文件，并返回字符数组，使用匿名内部类获得文件过滤器对象
       /* File[] files = dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if(pathname.isDirectory() || pathname.getName().endsWith(".pak")){
                    //返回true表示不过滤文件
                    return true;
                }
                return false;
            }
        });*/
        //使用Lambda表达式的标准格式优化
       /* File[] files=dir.listFiles((File file)->{
            if(file.isDirectory() || file.getName().endsWith(".pak")){
            //返回true表示不过滤文件
            return true;
        }
            return false;});*/

        //使用Lambda表达式的简化格式优化
       /* File[] files=dir.listFiles((File file)->{
                //返回true表示不过滤文件
                return file.isDirectory() || file.getName().endsWith(".pak");
           });*/

        //使用Lambda表达式的省略简化格式优化
        File[] files=dir.listFiles(file-> file.isDirectory() || file.getName().endsWith(".pak"));

        //遍历数组
        for(File file:files){
            //判断是否是普通文件
            if(file.isFile()){
                    System.out.println(file.getName());
                }else {
                printFile(file);
            }
        }
    }
}

File类、递归、文件搜索、文件过滤器优化、Lambda优化

猜你喜欢