File类 及 递归

1 File类

1.1 概述

java.io.File类：文件和目录路径名的抽象表示形式，主要用于文件和目录的创建、查找和删除等操作。

java把电脑中的文件和文件夹(目录)封装为了一个Fle类,我们可以使用File类对文件和文件夹进行操作

我们可以使用File类的方法：

• 创建一个文件/文件夹
• 删除文件/文件夹
• 获取文件/文件夹
• 判断文件/文件夹是否存在
• 对文件夹进行遍历
• 获取文件的大小

File类是一个与系统无关的类,任何的操作系统都可以使用这个类中的方法

重点:记住这三个单词

• file:文件
• directory:文件夹/目录
• path:路径

1.2 File类的静态成员变量 

        static String pathSeparator ：与系统有关的路径分隔符，为了方便，它被表示为一个字符串。

        static char pathSeparatorChar ：与系统有关的路径分隔符。

        static String separator ：与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。

        static char separatorChar ：与系统有关的默认名称分隔符。

操作路径：路径不能写死

windows：C:\Users\105\Documents\a.txt

Linux：C:/Users/105/Documents/a.txt

"C:"+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt"

import java.io.File;

public class DemoFile {
    public static void main(String[] args) {
        /**
         * static String pathSeparator ：与系统有关的路径分隔符，为了方便，它被表示为一个字符串。
         *
         * static char pathSeparatorChar ：与系统有关的路径分隔符。
         *
         * static String separator ：与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。
         *
         * static char separatorChar ：与系统有关的默认名称分隔符。
         */
        String pathSeparator= File.pathSeparator;
        System.out.println(pathSeparator);//路径分隔符，windows：分号，Linux：冒号

        String separator = File.separator;
        System.out.println(separator);//文件名称分隔符 windows：反斜杠\ Linux：正斜杠/

    }
}

输出：

        ;

        \

1.3 绝对路径和相对路径

路径:

        绝对路径:是一个完整的路径，以盘符(c:,D:)开始的路径        

        c:\\a.txt

        C:\\Users\itcast\\IdeaProjects\\shungyuan\\123.txt

        相对路径:是一个简化的路径，相对指的是相对于当前项目的根目录

        (c:\\Users\itcast\\IdeaProjects\\shungyuan)

        如果使用当前项目的根目录，路径可以简化书写
        C:\\Users\itcast\\IdeaProjects\\shungyuan\\123,txt-->简化为: 123.txt(可以省略项目的根目录)

注意:

        1.路径是不区分大小写

        2.路径中的文件名称分隔符windows使用反斜杠，反斜杠是转义字符,两个反斜杠代表一个普通的反斜杠

1.4 File类的构造方法

        File(string pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

参数:
        string pathname:字符串的路径名称

        路径可以是以文件结尾，也可以是以文件夹结尾

        路径可以是相对路径，也可以是绝对路径

        路径可以是存在，也可以是不存在

        创建File对象，只是把字符串路径封装为File对象，不考虑路径的真假情况

import java.io.File;

public class DemoFile2 {
    public static void main(String[] args) {
        //file类的构造方法
        show01();
    }

    /**
     *
     */
    private static void show01() {
        //不管真假
        File f1=new File("C:\\Users\\10530\\Documents\\自定义 Office 模板\\a.txt");
        System.out.println(f1);//重写了Object类的toString方法

        File f2=new File("C:\\Users\\10530\\Documents\\自定义 Office 模板");
        System.out.println(f2);

        File f3=new File("a.txt");
        System.out.println(f3);
    }
}

输出：

        

        File(String parent，String child) ：根据 parent 路径名字符串和 child 路径名字符串创建个新 File 实例。

参数:把路径分成了两部分

        String parent：父路径

        String child：子路径

好处:
        父路径和子路径，可以单独书写，使用起来非常灵活，父路径和子路径都可以变化。

import java.io.File;

public class DemoFile2 {
    public static void main(String[] args) {
        //file类的构造方法
        show02("c:\\","a.txt");
    }

    /**
     * File(string parent，string child) ：根据 parent 路径名字符串和 child 路径名字符串创建个新 File 实例。
     *
     * 参数:把路径分成了两部分
     *
     *  String parent：父路径
     *
     *  String child：子路径
     *
     * 好处:
     * 父路径和子路径，可以单独书写，使用起来非常灵活，父路径和子路径都可以变化。
     */
    private static void show02(String parent,String child) {
        File file=new File(parent,child);
        System.out.println(file);
    }
}

输出：

        c:\a.txt

        File(File parent, String child) ：根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。

参数:把路径分成了两部分

        File parent:父路径

        String child:子路径

好处:
        父路径和子路径，可以单独书写，使用起来非常灵活;

        父路径和子路径都可以变化父路径是File类型，可以使用Fle的方法对路径进行一些操作,再使用路径创建对象

import java.io.File;

public class DemoFile2 {
    public static void main(String[] args) {
        //file类的构造方法
        show03();
    }

    /**
     * File(File parent, String child) ：根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
     *
     * 参数:把路径分成了两部分
     *
     * File parent:父路径
     *
     * String child:子路径
     *
     * 好处:
     * 父路径和子路径，可以单独书写，使用起来非常灵活;
     *
     * 父路径和子路径都可以变化父路径是File类型，可以使用Fle的方法对路径进行一些操作,再使用路径创建对象
     */
    private static void show03() {
        File parent=new File("c:\\");
        File file=new File(parent,"hello.java");
        System.out.println(file);
    }

}

输出：

        c:\hello.java

1.5 常用方法

1.5.1 获取功能的方法

•         public String getAbsolutePath() :返回此File的绝对路径名字符串。
•         public String getPath() :将此File转换为路径名字符串。
•         public String getName(): 返回由此File表示的文件或目录的名称
•         public long length() :返回由此File表示的文件的长度

import java.io.File;

public class DemoFile3 {
    public static void main(String[] args) {
        show01();
        System.out.println("------------");
        show02();
        System.out.println("------------");
        show03();
        System.out.println("------------");
        show04();
    }

    /**
     * public long length() :返回由此File表示的文件的长度
     * 获取的是构造方法指向的文件的大小，以字节为单位
     * 注意：文件夹是没有大小概念的，不能获取文件夹的大小
     *      如果构造方法中给出的路径不存在，那么length方法返回0
     */
    private static void show04() {
        File f=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照\\1.png");
        long length = f.length();
        System.out.println(length);//3243459

        File f2=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照\\1.jpg");
        long length2 = f2.length();
        System.out.println(length2);//0,该图片不存在，返回0

        File f3=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照");
        long length3 = f3.length();
        System.out.println(length3);//0，文件夹没有大小概念
    }

    /**
     * public String getName(): 返回由此File表示的文件或目录的名称
     * 获取的是构造方法传递路径的结尾部分（文件/文件夹）
     */
    private static void show03() {
        File f=new File("D:\\Java文件\\JavaSE\\a.txt");
        String name = f.getName();
        System.out.println(name);//a.txt

        File f2=new File("D:\\Java文件\\JavaSE");
        String name2 = f2.getName();
        System.out.println(name2);//JavaSE
    }

    /**
     * public String getPath() :将此File转换为路径名字符串。
     */
    private static void show02() {
        File f=new File("D:\\Java文件\\JavaSE\\a.txt");
        File f2=new File("a.txt");
        String path1=f.getPath();
        System.out.println(path1);
        String path2=f2.getPath();
        System.out.println(path2);

        System.out.println(f);
        System.out.println(f.toString());
    }

    /**
     * public String getAbsolutePath() :返回此File的绝对路径名字符串。
     * 获取构造方法中传递的路径
     * 无论路径是绝对还是相对的，返回都是绝对路径
     */
    private static void show01() {
        File f=new File("D:\\Java文件\\JavaSE\\a.txt");
        String absolutePath = f.getAbsolutePath();
        System.out.println(absolutePath);//D:\Java文件\JavaSE\a.txt

        File f2=new File("a.txt");
        String absolutePath2 = f2.getAbsolutePath();
        System.out.println(absolutePath2);//D:\Java文件\JavaSE\a.txt
    }
}

 输出：

        

1.5.2 判断功能的方法

•         public boolean exists() : 此File表示的文件或目录是否实际存在
•         public boolean isDirectory() : 此File表示的是否为目录
•         public boolean isFile()：此File表示的是否为文件。

import java.io.File;

/**
 * File判断功能的方法
 */
public class DemoFile4 {
    public static void main(String[] args) {
        show01();
        System.out.println("----------");
        show02();
        System.out.println("----------");
    }

    /**
     * public boolean isDirectory() : 此File表示的是否为目录
     *      用于判断构造方法中给定的路径是否以文件夹结尾
     *          是：true
     *          否：false
     * public boolean isFile()：此File表示的是否为文件。
     *      用于判断构造方法中给定的路径是否以文件结尾
     *                是：true
     *                否：false
     * 注意：
     *      电脑硬盘中只有文件/文件夹，两个方法互斥
     *      这两个方法使用前提，路径必须是存在的，否则都返回false
     */
    private static void show02() {
        File f=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照\\12.png");
        //不存在就没有必要获取
        if (f.exists()){
            System.out.println(f.isDirectory());
            System.out.println(f.isFile());
        }

        File f2=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照\\1.png");
        if (f2.exists()){
            System.out.println(f2.isDirectory());//false
            System.out.println(f2.isFile());//true
        }

        File f3=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照");
        if (f3.exists()){
            System.out.println(f3.isDirectory());//true
            System.out.println(f3.isFile());//false
        }
    }

    /**
     * public boolean exists() : 此File表示的文件或目录是否实际存在
     * 用于判断构造方法中的路径是否存在
     *  存在：true
     *  不存在：false
     */
    private static void show01() {
        File f=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照\\1.png");
        System.out.println(f.exists());

        File f2=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照\\12.png");
        System.out.println(f2.exists());

        File f3=new File("DemoFile2.java");
        System.out.println(f3.exists());
    }

}

输出：

        

1.5.3 创建删除功能的方法

•         public boolean createNewFile() :当且仅当具有该名称的文件尚不存在时，创建一个新的空文件
•         public boolean delete() :删除由此File表示的文件或目录。
•         public boolean mkdir() :创建由此File表示的目录
•         public boolean mkdirs() :创建由此File表示的目录，包括任何必需但不存在的父目录

import java.io.File;
import java.io.IOException;

public class DemoFile5 {
    public static void main(String[] args) throws IOException {
        show01();
        System.out.println("-----------");
        show02();
        System.out.println("-----------");
        show03();
        System.out.println("-----------");
    }

    /**
     * public boolean delete() :删除由此File表示的文件或目录。
     *      此方法可以删除构造方法路径中给出的文件或文件夹
     *          返回值：布尔值
     *              true：文件或文件夹删除成功
     *              false：文件夹中有内容，不会删除，返回false；构造方法中的路径不存在
     * 注意：
     *      delete方法是直接在硬盘删除文件或文件夹，不走回收站，删除要谨慎
     */
    private static void show03() {
        File f=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照\\aaa");
        boolean d = f.delete();
        System.out.println("d:"+d);
    }

    /**
     * public boolean mkdir() :创建由此File表示的目录,
     *      创建单级文件夹
     * public boolean mkdirs() :创建由此File表示的目录，包括任何必需但不存在的父目录
     *      既可以创建单级文件夹，也可创建多级文件夹
     *
     * 创建文件的路径和名称在构造方法中给出（构造方法的参数）
     *      * 返回值：布尔值
     *      *      true：文件不存在，创建文件，返回true
     *      *      false：文件存在，不会创建，返回false；构造方法中给出的路径不存在也返回false
     *      * 注意：
     *      *      1.此方法只能创建文件夹，不能创建文件
     */
    private static void show02() {
        File f=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照\\aaa");
        boolean b=f.mkdir();
        System.out.println("b："+b);

        File f2=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照\\111\\222\\333");
        boolean b2=f2.mkdir();
        System.out.println("b2："+b2);

        File f3=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照\\111\\222\\333");
        boolean b3=f3.mkdirs();
        System.out.println("b3："+b3);

        File f4=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照\\aaa.txt");
        boolean b4=f4.mkdir();
        System.out.println("b4："+b4);//创建的也是文件夹，不是txt文件
    }

    /**
     * public boolean createNewFile() :当且仅当具有该名称的文件尚不存在时，创建一个新的空文件
     * 创建文件的路径和名称在构造方法中给出（构造方法的参数）
     * 返回值：布尔值
     *      true：文件不存在，创建文件，返回true
     *      false：文件存在，不会创建，返回false
     * 注意：
     *      1.此方法只能创建文件，不能创建文件夹
     *      2.创建文件的路径必须存在，否则会抛出异常
     *
     * Unhandled exception: java.io.IOException
     * createNewFile抛出了IOException异常，我们调用这个方法，必须处理这个异常，要么throws，要么try——catch
     */
    private static void show01() throws IOException {
        File f=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照\\1.txt");
        boolean b=f.createNewFile();
        System.out.println("b："+b);

        File f2=new File("C:\\Users\\10530\\OneDrive\\图片\\屏幕快照\\新建文件夹");
        boolean b2=f2.createNewFile();
        System.out.println("b2："+b2);
    }
}

输出：

        

1.6 File类遍历（文件夹）目录功能

        public string[] list() : 返回一个string数组，表示该File目录中的所有子文件或目录。

        public File[] listFiles() : 返回一个File数组，表示该File目录中的所有的子文件或目录。

注意:
        list方法和listFiles方法遍历的是构造方法中给出的目录

        如果构造方法中给出的目录的路径不存在，会抛出空指针异常

        如果构造方法中给出的路径不是一个目录，也会抛出空指针异常

import java.io.File;

public class DemoFile6 {
    public static void main(String[] args) {
        show01();
        System.out.println("-----------");
        show02();
    }

    /**
     * public File[] listFiles() : 返回一个File数组，表示该File目录中的所有的子文件或目录。
     * 遍历构造方法中给出的目录，会获得目录中所有文件或文件夹，把文件或文件夹封装为File对象，多个File对象存储到File数组中
     */
    private static void show02() {
        File file=new File("C:\\Users\\10530\\Pictures");
        File[] files=file.listFiles();
        for (File file1 : files) {
            System.out.println(file1);
        }
    }

    /**
     * public string[] list() : 返回一个string数组，表示该File目录中的所有子文件或目录。
     * 遍历构造方法中给出的目录，会获得目录中所有文件或文件夹的名称，把获取到的多个名称存储到一个String类型的数组中
     */
    private static void show01() {
        File file=new File("C:\\Users\\10530\\Pictures");
        String[] arr=file.list();
        for (String filename : arr) {
            System.out.println(filename);
        }
    }
}

输出：

        

2 递归

2.1 概述

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

递归的分类:

• 递归分为两种，直接递归和间接递归
• 直接递归称为方法自身调用自己
• 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法

注意事项：

• 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出
• 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出
• 构造方法,禁止递归

使用前提：

        当调用方法的时候，方法的主体不变，每次调用方法的参数不同，可以使用递归 

public class DemoRecurison {
    public static void main(String[] args) {
//        a();
        System.out.println("---------");
//        b(1);
        System.out.println("----------");

    }
    /**
     * 构造方法禁止递归
     *      编译报错，因为构造方法是创建对象时使用，一直递归就会导致内存中有无数个对象，直接编译报错
     */
    public DemoRecurison() {
//        DemoRecurison();
    }

    /**
     * 在递归中虽然有限定条件，但是递归次数不能太多，否则也会发生栈内存溢出
     *24044
     *      Exception in thread "main" java.lang.StackOverflowError
     */
    private static void b(int i) {
        System.out.println(i);
        if (i==30000){
            return;//结束方法
        }
        b(++i);
    }

    /**
     * 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出
     */
    private static void a() {
        System.out.println("a方法！");
        a();
    }
}

2.2 练习：递归累加求和

2.2.1 计算1~n的和

分析：

        num的累和=num+（num-1）的累和，所以可以把累和的操作定义为一个方法，递归调用。

/**
 * 计算1~n的和
 *
 */
public class DemoRecurison2 {
    public static void main(String[] args) {
        int s = sum(3);
        System.out.println(s);
        
    }
    /**
     * 定义一个方法，使用递归计算1~n的和
     *
     * 已知：
     *      最大值：n
     *      最小值：1
     * 使用递归必须明确：
     *      1.递归的结束条件：获取到1的时候结束
     *      2.递归的目的：获取下一个被加的数字（n-1）
     */
    public static int sum(int n){
        //获取到1的时候结束
        if (n==1){
            return 1;
        }
        //获取下一个被加的数字n-1
        return n+sum(n-1);
    }

}

 输出：

        6

2.2.2 递归求阶乘

分析：

        这与累和类似，只不过换成了乘法运算。

/**
 * 计算n的阶乘
 */
public class DemoRecurison3 {
    public static void main(String[] args) {
        int s = jc(5);
        System.out.println(s);

    }

    public static int jc(int n){
        //获取到1的时候结束
        if (n==1){
            return 1;
        }
        //获取下一个被加的数字n-1
        return n*jc(n-1);
    }
}

输出：

        120

2.2.3 递归打印多级目录

分析：

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

import java.io.File;

/**
 * 递归打印多级目录
 */
public class DemoRecurison4 {
    public static void main(String[] args) {
        File file=new File("C:\\Users\\10530\\Pictures");
        getAllFile(file);
    }
    /**
     * 定义一个方法，参数传递File类型的目录
     * 方法中对目录进行遍历
     */
    public static void getAllFile(File dir){
        File[] files=dir.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    }
}

输出：

         

import java.io.File;

/**
 * 递归打印多级目录
 */
public class DemoRecurison4 {
    public static void main(String[] args) {
        File file=new File("C:\\Users\\10530\\Pictures");
        getAllFile(file);
    }
    /**
     * 定义一个方法，参数传递File类型的目录
     * 方法中对目录进行遍历
     */
    public static void getAllFile(File dir){
        System.out.println(dir);//打印被遍历的目录名称
        File[] files=dir.listFiles();
        for (File file : files) {
            if (file.isDirectory()){
                getAllFile(file);
            }else {
                System.out.println(file);
            }

        }
    }
}

输出：

        

3 综合案例

3.1 文件搜索

        搜索“C:\\Users\\10530\\Pictures”目录中的 .jpg 文件。

分析：

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

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

import java.io.File;

/**
 * 搜索“C:\\Users\\10530\\Pictures”目录中的 .jpg 文件。
 */
public class DemoRecurison5 {
    public static void main(String[] args) {
        File file=new File("C:\\Users\\10530\\Pictures");
        getAllFile(file);
    }
    /**
     * 定义一个方法，参数传递File类型的目录
     * 方法中对目录进行遍历
     */
    public static void getAllFile(File dir){
        File[] files=dir.listFiles();
        for (File file : files) {
            if (file.isDirectory()){
                getAllFile(file);
            }else {
                //只要.jpg结尾的文件
                /**
                 * 1.把File对象转换为字符串对象
                 * 2.调用String类中的方法endsWith判断字符串是不是以.jpg结尾
                 * 3.如果是以.jpg结尾的文件，输出就可以了
                 */
//                String name = file.getName();//abc.java
//                String path = file.getPath();//c:\\abc\\abc.java
                String string = file.toString();//c:\\abc\\abc.java

                //把字符串转换成小写
                String s = string.toLowerCase();

                boolean b = string.endsWith(".jpg");

                if (b){
                    System.out.println(file);
                }
            }

        }
    }
}

优化代码：

/**
 * 搜索“C:\\Users\\10530\\Pictures”目录中的 .jpg 文件。
 */
public class DemoRecurison5 {
    public static void main(String[] args) {
        File file=new File("C:\\Users\\10530\\Pictures");
        getAllFile(file);
    }
    /**
     * 定义一个方法，参数传递File类型的目录
     * 方法中对目录进行遍历
     */
    public static void getAllFile(File dir){
        File[] files=dir.listFiles();
        for (File file : files) {
            if (file.isDirectory()){
                getAllFile(file);
            }else {
                //只要.jpg结尾的文件
                /**
                 * 1.把File对象转换为字符串对象
                 * 2.调用String类中的方法endsWith判断字符串是不是以.jpg结尾
                 * 3.如果是以.jpg结尾的文件，输出就可以了
                 */
                if (file.getName().toLowerCase().endsWith(".jpg")){
                    System.out.println(file);
                }
            }

        }
    }
}

输出：

         

3.2 文件过滤器优化

3.2.1 过滤器的介绍

        在File类中有两个和ListFiles重载的方法,方法的参数传递的就是过滤器。

        File[ ] listFiles(FileFilter filter)：

                java.io.FileFilter接口:用于抽象路径名(File对象)的过滤器

                作用: 用来过滤文件(File对象)

                抽象方法:用来过滤文件的方法

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

                参数:
                        File pathname：使用ListFiles方法遍历目录,得到的每一个文件对象

                       

        File[ ] listFiles(FilenameFilter filter)：

                java.io.FilenameFilter接口：实现此接口的类实例可用于过滤器文件名。

                作用：用于过滤文件名称

                抽象方法：用来过滤文件的方法
                        boolean accept(File dir，string name) ：测试指定文件是否应该包含在某一文件列表中。

                参数:
                        File dir：构造方法中传递的被遍历的目录

                        String name:使用ListFiles方法遍历目录,获取的每一个文件/文件夹的名称

注意：
        两个过滤器接口是没有实现类的，需要我们自己写实现类，重写过滤的方法accept，在方法中自己定义过滤的规则

3.2.2 练习：文件搜索案例的过滤器优化

          搜索“C:\\Users\\10530\\Pictures”目录中的 .jpg 文件。

   File[ ] listFiles(FileFilter filter)：

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

/**
 * 创建过滤器FileFilter的实现类，重写过滤方法accept，定义过滤规则
 */
public class FileFilterImpl implements FileFilter {
    @Override
    public boolean accept(File pathname) {
        return true;
    }
}

import java.io.File;

public class DemoFilter {
    public static void main(String[] args) {
        File file=new File("C:\\Users\\10530\\Pictures");
        getAllFile(file);
    }
    /**
     * 定义一个方法，参数传递File类型的目录
     * 方法中对目录进行遍历
     */
    public static void getAllFile(File dir){
        File[] files=dir.listFiles(new FileFilterImpl());//传递过滤器对象
        for (File file : files) {
            if (file.isDirectory()){
                getAllFile(file);
            }else {
                System.out.println(file);
            }

        }
    }
}

 输出：

        

方法一： 

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

/**
 * 创建过滤器FileFilter的实现类，重写过滤方法accept，定义过滤规则
 */
public class FileFilterImpl implements FileFilter {
    @Override
    public boolean accept(File pathname) {
        /**
         * 过滤的规则：
         *  在accept方法中，判断File对象是否以.jpg结尾
         *  是就返回true
         *  不是就返回false
         */
        if (pathname.isDirectory()){
            return true;
        }
        return pathname.getName().toLowerCase().endsWith(".jpg");
    }
}

import java.io.File;

public class DemoFilter {
    public static void main(String[] args) {
        File file=new File("C:\\Users\\10530\\Pictures");
        getAllFile(file);
    }
    /**
     * 定义一个方法，参数传递File类型的目录
     * 方法中对目录进行遍历
     */
    public static void getAllFile(File dir){
        File[] files=dir.listFiles(new FileFilterImpl());//传递过滤器对象
        for (File file : files) {
            if (file.isDirectory()){
                getAllFile(file);
            }else {
                System.out.println(file);
            }

        }
    }
}

输出：

         

方法二（优化后代码）：

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

public class DemoFilter2 {
    public static void main(String[] args) {
        File file=new File("C:\\Users\\10530\\Pictures");
        getAllFile(file);
    }
    /**
     * 定义一个方法，参数传递File类型的目录
     * 方法中对目录进行遍历
     */
    public static void getAllFile(File dir){
        //传递过滤器对象，使用匿名内部类
        File[] files=dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                //过滤规则，pathname是文件夹或者是.jpg结尾的文件返回true
                return pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".jpg");
            }
        });
        for (File file : files) {
            if (file.isDirectory()){
                getAllFile(file);
            }else {
                System.out.println(file);
            }

        }
    }
}

输出：
        

 File[ ] listFiles(FilenameFilter filter)：

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

public class DemoFilter3 {
    public static void main(String[] args) {
        File file=new File("C:\\Users\\10530\\Pictures");
        getAllFile(file);
    }
    /**
     * 定义一个方法，参数传递File类型的目录
     * 方法中对目录进行遍历
     */
    public static void getAllFile(File dir){
        //传递过滤器对象，使用匿名内部类
        File[] files=dir.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return new File(dir,name).isDirectory() || name.toLowerCase().endsWith(".jpg");
            }
        });
        for (File file : files) {
            if (file.isDirectory()){
                getAllFile(file);
            }else {
                System.out.println(file);
            }

        }
    }
}

输出：
         

3.3 Lambda优化 

        使用Lambda表达式优化上述案例的匿名内部类（接口中只有一个抽象方法）。

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

public class DemoFilterLambda {
    public static void main(String[] args) {
        File file=new File("C:\\Users\\10530\\Pictures");
        getAllFile(file);
    }
    /**
     * 定义一个方法，参数传递File类型的目录
     * 方法中对目录进行遍历
     */
    public static void getAllFile(File dir){
        //使用Lambda表达式优化匿名内部类（接口中只有一个抽象方法）
        File[] files=dir.listFiles((d, name)-> new File(d,name).isDirectory() || name.toLowerCase().endsWith(".jpg"));
        for (File file : files) {
            if (file.isDirectory()){
                getAllFile(file);
            }else {
                System.out.println(file);
            }

        }
    }
}

输出：