JAVA中File类（过滤器）以及递归

一.File类

1. 概述

java.io.File类
文件和目录路径名的抽象表示形式。
java把电脑中的文件和文件夹（目录）封装为了一个File类，我们可以使用File类对文件和文件夹进行操作
我们可以使用File类的方法
创建一个文件/文件夹
删除文件/文件夹
获取文件/文件夹
判断文件/文件夹是否存在
对文件夹进行遍历
获取文件的大小
File是一个与系统无关的类，任何的操作系统都可以使用这个类中的方法

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

2. 静态成员变量

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

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

        操作路径：路径不能写死了
        D:\java\java_SE windows
        D:/java/java_SE Linux
        "D:" + File.separator + "java" + File.separator + "java_SE"
        */

        String pathSeparator = File.pathSeparator;
        System.out.println(pathSeparator);//路径分隔符 windows:分号； Linux：冒号：

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

3. 绝对路径和相对路径

路径：
绝对路径：是一个完整的路径
以盘符（c:,d:）开始的路径
相对路径：是一个简化的路径
相对指的是相对于当前目录的根目录
如果使用当前目录的根目录，路径可以简化书写
D:\java\java_SE\123.txt -->简化为：123.txt(可以省略项目的根目录)

注意：
1.路径是不区分大小写
2.路径中的文件名称分隔符Windows使用反斜杠，反斜杠是转义字符，俩个反斜杠代表一个普通的反斜

4. 构造方法

（1）File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
参数：
String pathname:字符串的路径名称
路径可以是以文件结尾，也可以是以文件夹结尾
路径可以是相对路径，也可以是绝对路径
创建File对象，只是把字符串路径封装为File对象，不考虑路径的真假情况

（2）File(String parent, String child) 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
参数：把路径分为俩部分
String parent:父路径
String child:子路径
好处：
父路径和子路径，可以单独书写，使用非常灵活，父路径和子路径都可以变化

（3）File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
参数：把路径分为俩部分
String parent:父路径
String child:子路径
好处：
父路径和子路径，可以单独书写，使用非常灵活，父路径和子路径都可以变化
父路径是File类型，可以使用File的方法对路径进行一些操作，再使用路径创建对象

代码实现：

package File;

import java.io.File;

/*
    路径：
        绝对路径：是一个完整的路径
            以盘符（c:,d:）开始的路径
        相对路径：是一个简化的路径
            相对指的是相对于当前目录的根目录
            如果使用当前目录的根目录，路径可以简化书写
            D:\\java\\java_SE\\123.txt -->简化为：123.txt(可以省略项目的根目录)
        注意：
            1.路径是不区分大小写
            2.路径中的文件名称分隔符Windows使用反斜杠，反斜杠是转义字符，俩个反斜杠代表一个普通的反斜杠
 */
public class Demo02File {
    public static void main(String[] args) {
        /*
            File类的构造方法
         */
        show01();
        show02("c:\\","a.txt");
        show03();
    }

    /*
        File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
        参数：把路径分为俩部分
            String parent:父路径
            String child:子路径
        好处：
            父路径和子路径，可以单独书写，使用非常灵活，父路径和子路径都可以变化
            父路径是File类型，可以使用File的方法对路径进行一些操作，再使用路径创建对象

     */
    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) 根据 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);

    }

    /*
        File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
        参数：
            String pathname:字符串的路径名称
            路径可以是以文件结尾，也可以是以文件夹结尾
            路径可以是相对路径，也可以是绝对路径
            创建File对象，只是把字符串路径封装为File对象，不考虑路径的真假情况
     */
    private static void show01() {
        File f1 = new File("D:\\java\\java_SE\\a.txt");
        System.out.println(f1);//重写了Object类中的toString方法

        File f2 = new File("D:\\java\\java_SE");
        System.out.println(f2);

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

    }
}

5. File类常用方法

(1)获取功能的方法

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

代码实现

package getFile;

import java.io.File;

/*
    public String getAbsolutePath():返回此File的绝对路径名字符串
    public String getPath():将此File转换为路径名字字符串
    public String getName():返回此File表示的文件或目录的名称
    public String Length():返回由此File表示的文件的长度
 */
public class getMethod {
    public static void main(String[] args) {
        show01();
        System.out.println("-----------------------------");
        show02();
        System.out.println("--------------------------------");
        show03();
        System.out.println("------------------------------");
        show04();
    }

    /*
        public String Length():返回由此File表示的文件的长度
        获取的是构造方法指定的文件的大小，以字节为单位
        注意：
            文件夹是没有大小概念的，不能获取文件夹大小
            如果构造方法中给出的路径不存在，那么Length返回0


     */
    private static void show04() {
        File f1 = new File("D:\\java\\java_SE\\FileTestIO\\123.txt");
        long length = f1.length();
        System.out.println(length);
        System.out.println(new File("D:\\java\\java_SE\\FileTestIO").length());
        System.out.println(new File("D:\\java\\java_SE\\FileTestIO\\1.txt").length());
    }

    /*
        public String getName():返回此File表示的文件或目录的名称
        获取的就是构造方法传递路径的结尾部分（文件/文件夹）
     */
    private static void show03() {
        File f1 = new File("D:\\java\\java_SE\\FileAndRecursion\\123.txt");
        String name1 = f1.getName();
        System.out.println(name1);
        File f2 = new File("D:\\java\\java_SE\\FileAndRecursion");
        String name2 = f2.getName();
        System.out.println(name2);
    }

    /*
        public String getPath():将此File转换为路径名字字符串
        public String toString() {
            return this.getPath();
        }
        toString调用的就是getPath方法
     */
    private static void show02() {
        File f1 = new File("D:\\java\\java_SE\\FileAndRecursion\\123.txt");
        File f2 = new File("123.txt");
        String path1 = f1.getPath();
        String path2 = f2.getPath();
        System.out.println(path1);
        System.out.println(f1.toString());
        /*public String toString() {
            return this.getPath();
        }*/
        System.out.println(path2);
    }

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

        File f2 = new File("123.txt");
        String absolutePath1 = f2.getAbsolutePath();
        System.out.println(absolutePath1);
    }
}

（2）判断功能的方法

public boolean exists():此File表示的文件或目录是否实际存在
    public boolean isDirectory():此File表示的是否是目录
        用于判断构造方法中给定的路径是否以文件夹结尾

    public boolean isFile():此File表示的是否是文件
        用于判断构造方法中给定的路径是否以文件夹结尾
    注意：
        电脑的硬盘中只有文件/问价夹，俩个方法是互斥的
        这俩个方法使用的前提是路径必须是存在的，否则都返回False

（3）创建和删除功能

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

代码实现：

package CreateAndDeleteFile;

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

/*
    public boolean createNewFile():当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
    public boolean delete():删除由此File表示的文件和目录。
    public boolean mkdir():创建由此File表示的目录。
    public boolean mkdirs():创建由此File表示的目录，包括任何必需但不存在的父目录。
 */
public class CreateAndDelete {
    public static void main(String[] args) throws IOException {
        show01();
        show02();
        show03();
    }

    /*
        public boolean delete():删除由此File表示的文件和目录。
        此方法，可以删除构造方法中给出的文件/文件夹
        返回值：布尔值
            true：文件/文件夹删除成功，返回true
            false：文件夹中由内容，不会删除，返回false，构造方法中的路径不存在false
        注意：
            delete方法是直接在硬盘删除文件/文件夹，不走回收站
     */
    private static void show03() {
        File f1 = new File("D:\\java\\java_SE\\FileAndRecursion\\2.txt");
        System.out.println(f1.delete());
    }

    /*
        public boolean mkdir():创建单极文件夹
        public boolean mkdirs():既可以创建单级文件夹，也可以创建多级文件夹
        创建文件夹的路径和名称在构造方法中给出（构造方法的参数）
        返回值：布尔值
            true:文件夹不存在，创建文件
            false：文件夹存在，不会创建，构造路径中给出的路径不存在(也不会创建)，返回false
        注意：
            1.此方法只能创建文件夹，不能创建文件
     */
    private static void show02() {
        File f1 = new File("D:\\java\\java_SE\\FileAndRecursion\\aaa");
        System.out.println(f1.mkdir());

        File f2 = new File("D:\\java\\java_SE\\FileAndRecursion\\111\\222\\333");
        System.out.println(f2.mkdirs());
    }

    /*
        public boolean createNewFile():当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
        创建文件的路径和名称在构造方法中给出（构造方法的参数）
        返回值：布尔值
            true:文件不存在，创建文件
            false：文件存在，不会创建
        注意：
            1.此方法只能创建文件，不能创建文件夹
            2.创建文件的路径必须存在，否则会抛出异常

            public boolean createNewFile() throws IOException
            createNewFile声明抛出了IOException异常，必须处理这个异常，要么继续抛出throws,要么try catch
     */
    private static void show01() throws IOException {
        File f1 = new File("D:\\java\\java_SE\\FileAndRecursion\\1.txt");
        boolean newFile = f1.createNewFile();
        System.out.println(newFile);

        File f2 = new File("D:\\java\\java_SE\\FileAndRecursion\\2.txt");
        System.out.println(f2.createNewFile());
    }
}

6. File类目录的遍历

File类遍历（文件夹）目录功能
public String[] List():返回一个String数组，表示该File目录中的所有子文件和目录。
public File[] listFiles():返回一个File数组，表示该File目录中的所有子文件和目录。

注意：
List方法和ListFiles方法遍历的是构造方法中给出的目录
如果构造方法中给出的目录的路径不存在，就会抛出空指针异常
如果构造方法中给出的路径不是一个目录，也会抛出空指针异常

package TraversingFile;

import java.io.File;

/*
    File类遍历（文件夹）目录功能
        public String[] List():返回一个String数组，表示该File目录中的所有子文件和目录。
        public File[] listFiles():返回一个File数组，表示该File目录中的所有子文件和目录。

    注意：
        List方法和ListFiles方法遍历的是构造方法中给出的目录
        如果构造方法中给出的目录的路径不存在，就会抛出空指针异常
        如果构造方法中给出的路径不是一个目录，也会抛出空指针异常
 */
public class Traversing {
    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("D:\\java\\java_SE\\FileAndRecursion");
        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("D:\\java\\java_SE\\FileAndRecursion");
        //File file = new File("D:\\java\\java_SE\\FileAndRecu"); //Exception in thread "main" java.lang.NullPointerException
        //File file = new File("D:\\java\\java_SE\\FileAndRecursion\\1.txt");//Exception in thread "main" java.lang.NullPointerException
        String[] list = file.list();
        for (String fileName : list) {
            System.out.println(fileName);
        }
    }
}

二.递归

1.递归概述

递归的分类：
递归分为俩种，直接递归，间接递归。
直接递归称为方法调用自己。
间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。
递归的注意事项：
递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
在递归中虽然有限定条件，但是递归次数不能过多，否则也会发生栈内存溢出。
构造方法，禁止递归。
递归的使用前提：
当调用方法的时候，方法的主体不变，每次调用方法的参数不同，可以使用递归。

package Recursion;

/*
    递归的分类：
	    递归分为俩种，直接递归，间接递归。
	    直接递归称为方法调用自己。
	    间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。
    递归的注意事项：
        递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
        在递归中虽然有限定条件，但是递归次数不能过多，否则也会发生栈内存溢出。
        构造方法，禁止递归。
    递归的使用**前提**：
        当调用方法的时候，方法的主体不变，每次调用方法的参数不同，可以使用递归。
 */
public class Demo01Recursion {
    public static void main(String[] args) {
        //       a();
        //       b(1);
    }

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

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


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

2.使用递归计算1~n的和

package Recursion;

/*
    使用递归计算1~n的和
 */
public class example1_to_n {
    public static void main(String[] args) {
        int s = sum(3);
        System.out.println(s);
    }

    /*
        定义一个方法，使用递归计算1~n的和
        1+2+3+.....+n
        n+(n-1)+(n-2)+.....+1
        已知：
            最大值：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);
    }
}

3.递归求阶乘

package Recursion;

/*
    使用递归计算阶乘

 */
public class example2_factorial {
    public static void main(String[] args) {
        int fac = fac(5);
        System.out.println(fac);
    }

    private static int fac(int n) {
        if (n==1){
            return 1;
        }
        return n*fac(n-1);
    }
}

4.递归打印多级目录

package Recursion;

import java.io.File;

/*
    递归打印多级目录
 */
public class example_print {
    public static void main(String[] args) {

        File file = new File("D:\\java\\abc");
        getAllFile(file);

    }

    /*
        定义一个方法，参数传递File类型的目录
        方法中对目录进行遍历
     */
    public static void getAllFile(File dir) {
        File[] files = dir.listFiles();
        for (File f : files) {

            if (f.isDirectory()) {
                getAllFile(f);
            } else {
                System.out.println(f);
            }
        }
    }
}

5.搜索目录

package Recursion;

import java.io.File;

/*
    递归打印多级目录
    只要.java结尾的文件
    D:\java\abc\a\a.jpg
    D:\java\abc\a\a.txt
    D:\java\abc\abc.java
    D:\java\abc\abc.txt
    D:\java\abc\b\b.java
    D:\java\abc\b\b.txt
 */
public class example4_search {
    public static void main(String[] args) {

        File file = new File("D:\\java\\abc");
        getAllFile(file);

    }

    /*
        定义一个方法，参数传递File类型的目录
        方法中对目录进行遍历
     */
    public static void getAllFile(File dir) {
        File[] files = dir.listFiles();
        for (File f : files) {

            if (f.isDirectory()) {
                getAllFile(f);
            } else {
                /*
                只要.java结尾的文件
                1.把File对象f,转换为字符串对象
                 */
                String name = f.getName();//

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

                //2.调用String类中的endsWith判断字符串是否是以.java结尾

                boolean b = s.endsWith(".java");

                //3.如果是以.java结尾就输出

                if (b == true) {
                    System.out.println(f);
                }

                //链式编程
                if (f.getName().toLowerCase().endsWith(".java")){
                    System.out.println(f);
                }
            }
        }
    }
}

6.FileFilter过滤器

我们可以使用过滤器来实现需求
在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，在方法中自己定义过滤的规则

代码实现：
main

package Filter;

import java.io.File;

/*

    递归打印多级目录
    需求：
    只要.java结尾的文件
    D:\java\abc\a\a.jpg
    D:\java\abc\a\a.txt
    D:\java\abc\abc.java
    D:\java\abc\abc.txt
    D:\java\abc\b\b.java
    D:\java\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，在方法中自己定义过滤的规则

 */
public class example5_filter_file {
    public static void main(String[] args) {

        File file = new File("D:\\java\\abc");
        getAllFile(file);

    }

    /*
        定义一个方法，参数传递File类型的目录
        方法中对目录进行遍历
     */
    public static void getAllFile(File dir) {
        File[] files = dir.listFiles(new FileFilterImpl());//传递过滤器对象
        for (File f : files) {

            if (f.isDirectory()) {
                getAllFile(f);
            } else {
                System.out.println(f);
            }
        }
    }
}

实现类

package Filter;

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

/*
    创建过滤器FileFilter的实现类，重写过滤方法accept，定义过滤规则
 */
public class FileFilterImpl implements FileFilter {

    @Override
    public boolean accept(File pathname) {
        /*
        过滤规则：
            在accept方法中，判断Files对象是否是以.java结尾
            是就返回true
            不是就返回false
         */
        //如果pathname是一个文件夹，返回true，继续遍历文件夹
        if (pathname.isDirectory()) {
            return true;
        }
        return pathname.getName().toLowerCase().endsWith(".java");
    }
}