02_08_Java语音进阶||day08_File类、递归、综合案例(文件过滤器)

标签：02 day08 java String 文件夹 File Java txt public

第一章 File类

1.1 概述

（API）java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录（表示文件夹）的创建，查找和删除等操作。

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

我们可以使用File类的方法

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

注：File类是一个与系统无关的类,任何的操作系统都可以使用这个类中的方法
【重点】:记住这三个单词

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

1.2 File类的静态成员变量

路径分隔符

windows–>;(分号)
linux–>:（冒号）

文件路径分隔符

windows–>\(一个反斜杠)
linux–>/（正斜杠）

File类的静态成员变量

表示路径的

static String pathSeparator

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

static char pathSeparatorChar

与系统有关的路径分隔符。

表示文件的

static String separator

与系统有关的默认名称分隔符（文件名称分隔符），为了方便，它被表示为一个字符串。

static char separatorChar

与系统有关的默认名称分隔符（文件名称分隔符）。

代码演示：

public static void main(String[] args) {
        String pathSeparator = File.pathSeparator;
        System.out.println(pathSeparator);  //打印的；-->路径分隔符，

        String separator = File.separator;
        System.out.println(separator);  //打印的\

    }

注意事项：

操作路径：路径不能写死了

* c:\develop\a\a.txt  //windows
    * c:/develop/a/a.txt  //linux
    * "c:"+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt"

1.3 绝对路径和相对路径

路径:

绝对路径:是一个完整的路径

以盘符(c:,D:)开始的路径

c:\\a.txt
    C:\\Users\itcast\\IdeaProjects\\shungyuan\\123.txt
    D:\\demo\\b.txt

相对路径:是一个简化的路径

相对指的是相对于当前项目的根目录【重点】(C:\Users\itcast\IdeaProjects\shungyuan)
如果使用当前项目的根目录,路径可以简化书写

C:\\Users\itcast\\IdeaProjects\\shungyuan\\123.txt-->简化为: 123.txt(可以省略项目的根目录)

注意:

路径是不区分大小写
路径中的文件名称分隔符windows使用反斜杠,反斜杠是转义字符,两个反斜杠代表一个普通的反斜杠【重点】

1.4 File类的构造方法

File(String pathname)——>用的最多——【!】

通过将给定路径名字符串转换为抽象路径名来创建一个新 File实例【!】

参数:

++String pathname++:字符串的路径名称
路径可以是以文件结尾,也可以是以文件夹结尾
路径可以是相对路径,也可以是绝对路径
路径可以是存在,也可以是不存在

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

File(String parent, String child) ——【!】

根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

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

String parent:父路径
String child:子路径

好处:

父路径和子路径,可以单独书写,使用起来非常灵活;父路径和子路径都可以变化

File(File parent, String child) ——【!】

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

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

File parent:父路径
String child:子路径

好处:

父路径和子路径,可以单独书写,使用起来非常灵活;父路径和子路径都可以变化
父路径是File类型,可以使用File的方法对路径进行一些操作【重点】,再使用路径创建对象

//主方法Demo02File.java
    public class Demo02File {
        public static void main(String[] args) {
            //show01();
    
            //show02("C:\\", "a.txt");  //C:\a.txt
            //show02("d:\\", "a.txt");    //d:\a.txt
            
            show03();   //c:\hello.java
        }
    
        //File(File parent, String child) 构造方法
        private static void show03() {
            File parent = new File("c:\\");
            File file = new File(parent, "hello.java");
            System.out.println(file);
        }
    
        //File(==String parent==, String child) 构造方法
        private static void show02(String parent, String child) {
            File file = new File(parent, child);
            System.out.println(file);
        }
    
        //File(String pathname)构造方法
        private static void show01() {
            //以文件结尾
            File f1 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\a.txt");
            //重写了toString方法
            System.out.println(f1); //E:\JavaWebApp\WorkSpace\oop\a.txt
    
            //以文件夹结尾
            File f2 = new File("E:\\JavaWebApp\\WorkSpace\\oop");
            //重写了toString方法
            System.out.println(f2); //E:\JavaWebApp\WorkSpace\oop
    
            //相对路径
            File f3 = new File("b.txt");
            //重写了toString方法
            System.out.println(f3); //b.txt
        }
    }

1.5 File类常用方法—获取功能的方法

File类获取功能的方法

public String getAbsolutePath()——【!】

返回此File的绝对路径名字符串。

获取的构造方法中传递的路径
无论路径是绝对的还是相对的,getAbsolutePath方法返回的都是绝对路径

public String getPath()——【!】

将此File转换为路径名字符串。

路径是什么样就是什么样
重写toString方法用的就是getPath方法

源码：

public String toString() {
        return getPath();
    }

public String getName()——【!】

获取的就是构造方法传递路径的结尾部分(文件/文件夹)【!】
绝对相对都可以

public ++long++ length()——【!】

返回由此File表示的文件的长度。
获取的是构造方法指定的文件的大小【!】,以字节为单位
注意:

文件夹是没有大小概念的,不能获取文件夹的大小
如果构造方法中给出的路径不存在,那么length方法返回0

public class Demo03File {
        public static void main(String[] args) {
            //show01();
            //show02();
            //show03();
            show04();
        }
    
        //public long ==length==()
        private static void show04() {
            //存在的文件
            File f1 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\a.txt");
            long l1 = f1.length();
            System.out.println(l1);  //11(字节)
            //不存在的文件
            File f2 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\b.txt");
            long l2 = f2.length();
            System.out.println(l2);  //0(字节)
            //传入一个文件夹
            File f3 = new File("c:\\JavaWebApp");
            long l3 = f3.length();
            System.out.println(l3);  //0：文件夹没有大小概念
        }
    
        //public String ==getName==()
        private static void show03() {
            //文件结尾
            File f1 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\a.txt");
            String absolutePath1 = f1.getName();
            System.out.println(absolutePath1);  //a.txt
            //文件夹结尾
            File f2 = new File("E:\\JavaWebApp\\WorkSpace\\oop");
            String absolutePath2 = f2.getName();
            System.out.println(absolutePath2);  //oop
        }
    
        //public String ==getPath==()
        private static void show02() {
            //绝对路径
            File f1 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\a.txt");
            String absolutePath1 = f1.getPath();
            System.out.println(absolutePath1);  //E:\JavaWebApp\WorkSpace\oop\a.txt
            //相对路径
            File f2 = new File("a.txt");
            String absolutePath2 = f2.getPath();
            System.out.println(absolutePath2);  //a.txt
    
            System.out.println(f1); //E:\JavaWebApp\WorkSpace\oop\a.txt
            System.out.println(f1.toString());  //E:\JavaWebApp\WorkSpace\oop\a.txt
        }
    
        //public String ==getAbsolutePath==()
        private static void show01() {
            //绝对路径
            File f1 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\a.txt");
            String absolutePath1 = f1.getAbsolutePath();
            System.out.println(absolutePath1);  //E:\JavaWebApp\WorkSpace\oop\a.txt
            //相对路径
            File f2 = new File("a.txt");
            String absolutePath2 = f2.getAbsolutePath();
            System.out.println(absolutePath2);  //E:\JavaWebApp\WorkSpace\oop\a.txt
        }
    }

1.6 File类常用方法—判断功能的方法

File类判断功能的方法

public boolean exists()——【!】

用于判断构造方法中的路径是否存在

存在:true
不存在:false

public boolean isDirectory()——【!】

用于判断构造方法中给定的路径是否以文件夹结尾

是:true
否:false

public boolean isFile()——【!】

此File表示的是否为文件。

用于判断构造方法中给定的路径是否以文件结尾

是:true
否:false

isDirectory与isFile方法注意事项：

电脑的硬盘中只有文件/文件夹,两个方法是互斥
这两个方法使用前提,路径必须是存在的,否则都返回false
使用这两个方法之前需要判断一下路径是否存在

File f1 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\a.txt");
    if(f1.exists()){
        System.out.println(f1.isDirectory());   //false
        System.out.println(f1.isFile());   //true
    }

public class Demo04File {
        public static void main(String[] args) {
            //show01();
            show02();
        }
    
        //public boolean ==isDirectory==()
        private static void show02() {
            File f1 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\a.txt");
            if(f1.exists()){
                System.out.println(f1.isDirectory());   //false
                System.out.println(f1.isFile());   //true
            }
    
            File f3 = new File("E:\\JavaWebApp\\WorkSpace\\oop");
            if(f3.exists()){
                System.out.println(f3.isDirectory());    //true
                System.out.println(f3.isFile());    //false
            }
        }
    
        //public boolean ==exists==()
        private static void show01() {
            //文件路径
            File f1 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\a.txt");
            System.out.println(f1.exists());    //true
            File f2 = new File("oop\\b.txt");   //相对路径
            System.out.println(f2.exists());    //false
            //文件夹路径
            File f3 = new File("E:\\JavaWebApp\\WorkSpace\\oop");
            System.out.println(f3.exists());    //true
        }
    }

1.7 File类常用方法—创建删除功能的方法

File类创建删除功能的方法

public boolean createNewFile()——【!】

当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。

创建文件的路径和名称在构造方法中给出(构造方法的参数)
返回值:布尔值

true:文件不存在,创建文件,返回true
false:文件存在,不会创建,返回false

注意:

此方法只能创建文件,不能创建文件夹

“新建文件夹”–>是个文件：看类型不要看名称【!】

创建文件的路径必须存在,否则会抛出异常IOException【重点】
public boolean createNewFile() throws IOException

createNewFile声明抛出了IOException,我们调用这个方法,就必须的处理这个异常,要么throws,要么trycatch【重点】

public boolean delete()——【!】

此方法,可以删除构造方法路径中给出的文件/文件夹
返回值:布尔值

true:文件/文件夹删除成功,返回true
false:文件夹中有内容,不会删除返回false;构造方法中路径不存在false

注意:

delete方法是直接在硬盘删除文件/文件夹,不走回收站,删除要谨慎【重点】
多级的文件夹不能从前面直接删除【!】

public boolean mkdir()——【!】

创建单级空文件夹

public boolean mkdirs()——【!】

创建由此File表示的目录，包括任何必需但不存在的父目录。

既可以创建单级空文件夹,也可以创建多级文件夹

mkdir和mkdirs方法共性与区别：

创建文件夹的路径和名称在构造方法中给出(构造方法的参数)

返回值:布尔值

true:文件夹不存在,创建文件夹,返回true
false:文件夹存在,不会创建,返回false;构造方法中给出的路径不存在返回false

注意:

此方法只能创建文件夹,不能创建文件

“新建文件夹.txt”–>是个文件夹：看类型不要看名称【!】

创建文件的路径可以不存在,不会抛出异常，没有路径就不会创建【重点】

public class Demo05File {
        public static void main(String[] args) throws IOException {
            //show01();
            //show02();
            //show03();
        }
    
        //public boolean ==delete==()
        private static void show03() {
            //绝对路径下删除了b.txt文件
            File f1 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\b.txt");
            boolean d1 = f1.delete();
            System.out.println("d1:" + d1);
            //相对路径下删除了c.txt文件
            File f2 = new File("c.txt");
            boolean d2 = f2.delete();
            System.out.println("d2:" + d2);
    
            //绝对路径下删除了bbb文件
            File f3 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\bbb");
            boolean d3 = f3.delete();
            System.out.println("d3:" + d3);
            //相对路径下删除了aaa文件（多级）——不能删除
            File f4 = new File("aaa");
            boolean d4 = f4.delete();
            System.out.println("d4:" + d4); //false
        }
    
        //public boolean ==mkdir==()
        //public boolean ==mkdirs==()
        private static void show02() {
            //绝对路径下创建一个bbb文件夹
            File f1 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\bbb");
            boolean b1 = f1.mkdir();
            System.out.println("b1:" + b1); //b1:true
    
            //相对路径下创建aaa\\bbb\\ccc\\ddd文件夹多级文件夹
            File f2 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\aaa\\bbb\\ccc\\ddd");
            boolean b2 = f2.mkdirs();
            System.out.println("b2:" + b2); //b1:true
    
        }
    
        //public boolean ==createNewFile==()
        private static void show01() throws IOException {
            //绝对路径下创建一个b.txt文件
            File f1 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\b.txt");
            boolean b1 = f1.createNewFile();
            System.out.println("b1" + b1);  //true
            System.out.println(f1);
    
            //相对路径下创建一个c.txt文件
            File f2 = new File("c.txt");
            boolean b2 = f2.createNewFile();
            System.out.println("b2" + b2);  //true
            System.out.println(f2);
        }
    }

1.8 File类常用方法—目录（文件夹）的遍历

public String[] list()——【!】

返回一个String数组，表示该File目录中的所有子文件或目录。

遍历构造方法中给出的目录,会获取目录中所有文件/文件夹的名称【!】,把获取到的多个名称存储到一个String类型的数组中
list方法不管是不是绝对相对路径打印出来的都是文件/文件夹名称

public File[] listFiles()——【!】

返回一个File数组，表示该File目录中的所有的子文件或目录。

遍历构造方法中给出的目录,会获取目录中所有的文件/文件夹,把文件/文件夹封装为File对象【!】,多个File对象存储到File数组中
listFiles方法绝对路径打印出来的是文件/文件夹名称整个路径，相对路径时打印出来的是文件/文件夹名称

注意:

list方法和listFiles方法遍历的是构造方法中给出的目录
如果构造方法中给出的目录的路径不存在,会抛出空指针异常【!】
如果构造方法中给出的路径不是一个目录,也会抛出空指针异常【!】
能遍历到隐藏的文件和文件夹
list方法不管是不是绝对相对路径打印出来的都是文件/文件夹名称
listFiles方法绝对路径打印出来的是文件/文件夹名称整个路径，相对路径时打印出来的是文件/文件夹名称

public class Demo06File {
        public static void main(String[] args) {
            show01();
            //show02();
        }
    
        //public File[] listFiles
        private static void show02() {
            File f1 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\Dark-horse-teaching");
            File[] arr = f1.listFiles();
            //增强for打印(每个文件和文件夹的名称)
            for (File f : arr) {
                System.out.println(f);
            }
        }
    
        //public String[] ==list==()
        private static void show01() {
            File f1 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\Dark-horse-teaching");
            String[] arr = f1.list();
            //增强for打印(每个文件和文件夹的名称)
            for (String fileName : arr) {
                System.out.println(fileName);
            }
        }
    }
    
    //show01()的结果：
    Dark-horse-teaching.iml
    pic
    src
    
    //show02()的结果：
    E:\JavaWebApp\WorkSpace\oop\Dark-horse-teaching\Dark-horse-teaching.iml
    E:\JavaWebApp\WorkSpace\oop\Dark-horse-teaching\pic
    E:\JavaWebApp\WorkSpace\oop\Dark-horse-teaching\src

第二章递归

2.1 概述

递归:方法自己调用自己
递归的分类:

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

注意事项：

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

注：当一个方法调用其他方法的时候，被调用的方法没有执行完毕，当前方法会一直等待调用的方法执行完毕，才会继续执行
java.lang.StackOverflowError

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

java.lang.StackOverflowError

构造方法,禁止递归

编译报错：构造方法是创建对象使用的，一直递归会导致内存中有无数多个对象，直接编译报错

递归的使用前提:

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

public class Demo01Recurison {
        public static void main(String[] args) {
            //a();
            b(1);
        }
    
        /*
            构造方法,禁止递归
                编译报错
         */
        /*public Demo01Recurison() {
            Demo01Recurison();
        }*/
    
        //在递归中==虽然有限定条件==，==但是递归次数不能太多==。否则也会发生栈内存溢出
        //java.lang.StackOverflowError
        private static void b(int i) {
            System.out.println(i);
            if(i == 20000){
                return; //结束方法
            }
            b(++i);
        }
    
        //递归一定==要有条件限定==，==保证递归能够停止==下来，否则会发生栈内存溢出。
        //java.lang.StackOverflowError
        private static void a() {
            System.out.println("a方法");
            a();
        }
    }

2.2 递归累加求和

02_08_Java语音进阶||day08_File类、递归、综合案例(文件过滤器)_System

public class Demo02Recurison {
        public static void main(String[] args) {
            int s = sum(3);
            System.out.println(s);
        }
    
        //递归计算1-n的和
        public static int sum (int n){
            //获取到1时候结束
            if(n == 1){
                return 1;
            }
    
            //获取下一个被加的数字
            return n + sum(n - 1);
        }
    }

使用递归计算1~n之和的原理

注：

使用递归求和，main方法调用sum方法，sum方法会一直调用sum方法，导致在内存在有多个sum方法（频繁的创建方法，调用方法，销毁方法）——效率低下

2.3 递归求阶乘

02_08_Java语音进阶||day08_File类、递归、综合案例(文件过滤器)_开发语言_02

阶乘：所有小于及等于该数的正整数的积

public class Demo03Recurison {
        public static void main(String[] args) {
            int j = jc(5);
            System.out.println(j);
        }
    
        //递归计算1-n的和
        public static int jc (int n){
            //获取到1时候结束
            if(n == 1){
                return 1;
            }
    
            //获取下一个被乘的数字
            return n * jc(n - 1);
        }
    }
    
    //结果：
    120

方法的参数变化：5,4,3,2,1

2.4 递归打印多级目录

02_08_Java语音进阶||day08_File类、递归、综合案例(文件过滤器)_分隔符_03

2. 需求:

遍历项目根目录下day08Test文件夹,及day08Test文件夹的子文件夹 day08Test day08Test\a day08Test\a\a.java day08Test\a\a.png day08Test\abc.java day08Test\abc.txt day08Test\b day08Test\b\b.java day08Test\b\b.txt 3. 不用递归出现的问题及解决方法

02_08_Java语音进阶||day08_File类、递归、综合案例(文件过滤器)_分隔符_04

public class Demo04Recurison {
        public static void main(String[] args) {
            File file = new File("day08Test");
            getAllFile(file);
        }
    
        //参数传递File类型的目录，方法中对目录进行遍历
        public static void getAllFile(File dir){
            System.out.println(dir);    //打印被遍历的目录
            File[] files = dir.listFiles();
            for (File f : files) {
                //对遍历得到的file对象f进行判断，判断是否是文件夹
                if(f.isDirectory()){
                    //f是文件夹，就继续遍历这个文件夹
                    getAllFile(f);
                }else {
                    //f是文件，直接打印即可
                    System.out.println(f);
                }
            }
        }
    }
    
    //结果：
    day08Test
    day08Test\a
    day08Test\a\a.JAVA
    day08Test\a\a.png
    day08Test\abc.java
    day08Test\abc.txt
    day08Test\b
    day08Test\b\b.java
    day08Test\b\b.txt

第三章综合案例

3.1 文件搜索

02_08_Java语音进阶||day08_File类、递归、综合案例(文件过滤器)_构造方法_05

2. 需求:

遍历项目根目录下day08Test文件夹,及day08Test文件夹的子文件夹只要.java结尾的文件 day08Test day08Test\a day08Test\a\a.JAVA day08Test\a\a.png day08Test\abc.java day08Test\abc.txt day08Test\b day08Test\b\b.java day08Test\b\b.txt 3. 分析：

* 2.4不动，只需要改输出

1. 把File对象f，转为字符串对象(三种方式)

* String name = f.getName();

* String name = f.getPath();

* String name = f.toString();

2. 调用String类中的方法endsWith判断字符串是不是以.java结尾的

* boolean b = name.endsWith(“.java”);

3. if语句，如果是.java结尾的返回true，就输出

public class Demo05Recurison {
        public static void main(String[] args) {
            File file = new File("day08Test");
            getAllFile(file);
        }
    
        //参数传递File类型的目录，方法中对目录进行遍历
        public static void getAllFile(File dir){
            //System.out.println(dir);    //打印被遍历的目录
            File[] files = dir.listFiles();
            for (File f : files) {
                //对遍历得到的file对象f进行判断，判断是否是文件夹
                if(f.isDirectory()){
                    //f是文件夹，就继续遍历这个文件夹
                    getAllFile(f);
                }else {
                    //f是文件，直接打印即可
                    /*
                        day08Test\a\a.java
                        只要.java文件
                        1. 把File对象f，转为字符串对象
                        2. 调用String类中的方法endsWith判断字符串是不是以.java结尾的
                        3. if语句，如果是.java结尾的返回true，就输出
                     */
                    //String name = f.getName();
                    String name = f.getPath();
                    boolean b = name.endsWith(".java");
                    if(b){
                        System.out.println(f);
                    }
                }
            }
        }
    }
    
    //结果：
    day08Test\a\a.JAVA
    day08Test\abc.java
    day08Test\b\b.java

3.2 文件过滤器优化

需求:

遍历c:\\abc文件夹,及abc文件夹的子文件夹
    只要.java结尾的文件
    c:\\abc
    c:\\abc\\abc.txt
    c:\\abc\\abc.java
    c:\\abc\\a
    c:\\abc\\a\\a.jpg
    c:\\abc\\a\\a.JAVA
    c:\\abc\\b
    c:\\abc\\b\\b.java
    c:\\abc\\b\\b.txt

我们可以使用过滤器来实现
在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.3 FileFilter过滤器原理和使用

需求:

遍历c:\\abc文件夹,及abc文件夹的子文件夹
    只要.java结尾的文件
    c:\\abc
    c:\\abc\\abc.txt
    c:\\abc\\abc.java
    c:\\abc\\a
    c:\\abc\\a\\a.jpg
    c:\\abc\\a\\a.JAVA
    c:\\abc\\b
    c:\\abc\\b\\b.java
    c:\\abc\\b\\b.txt

必须明确两件事

过滤器中的accept方法是谁调用的？

listFiles方法

accept方法的参数pathname是什么？

listFiles传递过来的File++对象【重点-是个对象所以判断先需要转字符串】++

listFiles方法一共做了3件事：

listFiles方法会对构造方法中传递的目录进行遍历，获取目录中的每一个文件/文件夹–>封装为File对象
listFiles方法会调用参数传递的过滤器中的方法accept
listFiles方法会把遍历得到的每一个File对象，传递过accept方法的参数pathname

FileFilter接口的实现类中，重写的accept方法返回的是布尔值

true：就会把传递过去的File对象保存到File数组中。
false：就不会把传递过去的File对象保存到File数组中。

过滤的规则：

在accept方法中，判断File对象是否以.java结尾

是返回true
不是返回false

02_08_Java语音进阶||day08_File类、递归、综合案例(文件过滤器)_java_06

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

    //定义一个FileFilter接口的实现类：FileFilterImpl.java
    //重写accept方法
    public class FileFilterImpl implements FileFilter {

        @Override
        public boolean accept(File pathname) {
            /*
             * ==在accept方法中==，==判断File对象是否以.java结尾==
             * 是返回true
             * 不是返回false
             */
            //如果pathname是一个文件夹，就返回true，继续遍历这个文件夹
            if(pathname.isDirectory()){
                return true;
            }else {
                return pathname.getName().toLowerCase().endsWith(".java");  //.toLowerCase()将大写File对象转为小写来进行判断
            }
        }
    }
    
    import java.io.File;
    
    //主方法：Demo01Filter.java
    public class Demo01Filter {
        public static void main(String[] args) {
            File file = new File("day08Test");
            getAllFile(file);
        }
    
        //参数传递File类型的目录，方法中对目录进行遍历
        public static void getAllFile(File dir){
            File[] files = dir.listFiles(new FileFilterImpl()); //传递过滤器对象
            for (File f : files) {
                //对遍历得到的file对象f进行判断，判断是否是文件夹
                if(f.isDirectory()){
                    //f是文件夹，就继续遍历这个文件夹
                    getAllFile(f);
                }else {
                    //f是文件，直接打印即可
                    System.out.println(f);
                }
            }
        }
    }
    
    //结果：
    day08Test\a\a.JAVA
    day08Test\abc.java
    day08Test\b\b.java

3.4 FilenameFilter过滤器的使用

重写的accept(File dir, String name)方法注意事项：

使用步骤：

将两个参数封装成一个File对象【!】

new File(dir, name)
父路径就是一个目录
子路径就是目录中文件的名称

例子：

//传递过滤器对象——使用匿名内部类(FilenameFilter接口的)
    File[] files = dir.listFiles(new FilenameFilter() {
        @Override
        public boolean accept(File dir, String name) {
            //过滤规则：pathname是文件夹或者.java结尾的返回true
            return new File(dir, name).isDirectory() || name.toLowerCase().endsWith(".java");
        }
    });

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

    //主方法：Demo02Filter.java
    public class Demo02Filter {
        public static void main(String[] args) {
            File file = new File("day08Test");
            getAllFile(file);
        }
    
        //参数传递File类型的目录，方法中对目录进行遍历
        public static void getAllFile(File dir){
            //传递过滤器对象——使用匿名内部类(FileFilter接口的)
            /*File[] files = dir.listFiles(new FileFilter() {
                @Override
                public boolean accept(File pathname) {
                    //过滤规则：pathname是文件夹或者.java结尾的返回true
                    return pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java");
                }
            });*/
            //传递过滤器对象——使用匿名内部类(FilenameFilter接口的)
            File[] files = dir.listFiles(new FilenameFilter() {
                @Override
                public boolean accept(File dir, String name) {
                    //过滤规则：pathname是文件夹或者.java结尾的返回true
                    return new File(dir, name).isDirectory() || name.toLowerCase().endsWith(".java");
                }
            });
            for (File f : files) {
                //对遍历得到的file对象f进行判断，判断是否是文件夹
                if(f.isDirectory()){
                    //f是文件夹，就继续遍历这个文件夹
                    getAllFile(f);
                }else {
                    //f是文件，直接打印即可
                    System.out.println(f);
                }
            }
        }
    }
    
    //结果：
    day08Test\a\a.JAVA
    day08Test\abc.java
    day08Test\b\b.java

3.5 Lambda优化程序

不管是FileFiter还是FileNameFileter接口实现类都只有一个抽象方法【重点】，所以可以使用Lambda表达式【重点】

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

    public class Demo02Filter {
        public static void main(String[] args) {
            File file = new File("day08Test");
            getAllFile(file);
        }
    
        //参数传递File类型的目录，方法中对目录进行遍历
        public static void getAllFile(File dir){
            //传递过滤器对象——使用匿名内部类(FileFilter接口的)
            /*File[] files = dir.listFiles(new FileFilter() {
                @Override
                public boolean accept(File pathname) {
                    //过滤规则：pathname是文件夹或者.java结尾的返回true
                    return pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java");
                }
            });*/
            //传递过滤器对象——使用匿名内部类(FilenameFilter接口的)
            /*File[] files = dir.listFiles(new FilenameFilter() {
                @Override
                public boolean accept(File dir, String name) {
                    //过滤规则：pathname是文件夹或者.java结尾的返回true
                    return new File(dir, name).isDirectory() || name.toLowerCase().endsWith(".java");
                }
            });*/
    
            //以上是匿名内部类
            //==================================================
            //以下是Lambda表达式——(FilenameFilter接口的)
    
            ///使用Lambda表达式优化匿名内部类——(FilenameFilter接口的)
            /*File[] files = dir.listFiles((File d, String name)->{
                //过滤规则：pathname是文件夹或者.java结尾的返回true
                return new File(d, name).isDirectory() || name.toLowerCase().endsWith(".java");
            });*/
    
            ///简化Lambda表达式——(FilenameFilter接口的)
            //多个参数的数据类型可以省略
            //方法体是一行的时候：{}，return，;要一起省略
            //File[] files = dir.listFiles((d,  name)->new File(d, name).isDirectory() || name.toLowerCase().endsWith(".java"));
    
            //以上是Lambda表达式——(FilenameFilter接口的)
            //==================================================
            //以下是Lambda表达式——(FileFilter接口的)
    
            //使用Lambda表达式优化匿名内部类——(FileFilter接口的)
            /*File[] files = dir.listFiles((File pathname) -> {
                return pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java");
            });*/
    
            ///简化Lambda表达式——(FileFilter接口的)
            //一个参数的数据类型可以省略，小括号也可以省略
            //方法体是一行的时候：{}，return，;要一起省略
            File[] files = dir.listFiles(pathname -> pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java"));
    
            for (File f : files) {
                //对遍历得到的file对象f进行判断，判断是否是文件夹
                if(f.isDirectory()){
                    //f是文件夹，就继续遍历这个文件夹
                    getAllFile(f);
                }else {
                    //f是文件，直接打印即可
                    System.out.println(f);
                }
            }
        }
    }
    
    //结果：
    day08Test\a\a.JAVA
    day08Test\abc.java
    day08Test\b\b.java

标签：02,day08,java,String,文件夹,File,Java,txt,public
From： https://blog.51cto.com/u_15980166/6086815

02_08_Java语音进阶||day08_File类、递归、综合案例(文件过滤器)

第一章 File类

1.1 概述

1.2 File类的静态成员变量

1.3 绝对路径和相对路径

1.4 File类的构造方法

1.5 File类常用方法—获取功能的方法

1.6 File类常用方法—判断功能的方法

1.7 File类常用方法—创建删除功能的方法

1.8 File类常用方法—目录（文件夹）的遍历

第二章递归

2.1 概述

2.2 递归累加求和

2.3 递归求阶乘

2.4 递归打印多级目录

第三章综合案例

3.1 文件搜索

3.2 文件过滤器优化

3.3 FileFilter过滤器原理和使用

3.4 FilenameFilter过滤器的使用

3.5 Lambda优化程序

相关文章

赞助商

阅读排行

02_08_Java语音进阶||day08_File类、递归、综合案例(文件过滤器)

第一章 File类

1.1 概述

1.2 File类的静态成员变量

1.3 绝对路径和相对路径

1.4 File类的构造方法

1.5 File类常用方法—获取功能的方法

1.6 File类常用方法—判断功能的方法

1.7 File类常用方法—创建删除功能的方法

1.8 File类常用方法—目录（文件夹）的遍历

第二章 递归

2.1 概述

2.2 递归累加求和

2.3 递归求阶乘

2.4 递归打印多级目录

第三章 综合案例

3.1 文件搜索

3.2 文件过滤器优化

3.3 FileFilter过滤器原理和使用

3.4 FilenameFilter过滤器的使用

3.5 Lambda优化程序

相关文章

赞助商

阅读排行

第二章递归

第三章综合案例