IO-File类、递归、过滤器

一、Feil类

    1、计算机名词解释

目录（Directory）： 文件夹。 用来存放文件。

    文件（File）： 用来存储数据。

    路径（Path）： 路径包括文件也包括文件夹。 相当于计算机中的一个位置， 这个位置可以是文件或者文件夹。

    在Java中有一个类叫做File，这个类表示计算机中的文件或者文件夹（路径）

    注意：File这个单词本意是文件的意思，但是在Java中不仅仅可以表示文件，还可以表示文件夹。

    File类中还有很多方法，我们可以通过这些方法完成很多对文件或者文件夹的操作。

2、File类的构造方法

        File(String pathname)： 使用给定的文件或者文件夹的路径构建一个File对象

        File(String parent, String child)：使用父路径和子路径组合构造一个File对象

                    比如，一个文件的路径为：D:\aaa\a1\bb\hello.java

                    其中父路径为： D:\aaa\a1\bb

                    其中子路径为： hello.java

        File(File parent, String child)： 将父路径和子路径组合构造一个File

    注意：

        File表示计算机中的一个文件或者文件夹，这个文件或者文件夹可以在计算机中是已经存在的

        也可以是不存在的。

public class Demo02FileConstructor {

    public static void main(String[] args) {

        method3();

    }

 

    //File(File parent, String child)： 将父路径和子路径组合构造一个File

    public static void method3() {

        //创建一个File对象表示父路径

        File parent = new File("d:\\iotest");

        //使用父路径和子路径组合构造一个File。 这个file对象表示的是d:\iotest\bb

        File file = new File(parent, "bb");

        //打印结果

        System.out.println(file);

    }

 

    //File(String parent, String child)：使用父路径和子路径组合构造一个File对象

    public static void method2() {

        //使用父路径和子路径组合构造一个File对象， 这个File对象表示的是 d:\iotest\a.txt

        File file = new File("d:\\iotest", "a.txt");

        System.out.println(file);

    }

 

    // File(String pathname)： 使用给定的文件或者文件夹的路径构建一个File对象

    public static void method1() {

        //创建对象

        //在java中\是一个特殊的字符，叫做转义字符，用来对后面的字符改变意思。

        //在java中，如果想要表示一个没有特殊含义的反斜线，需要写两个 \\

        File file = new File("d:\\a.txt");

        System.out.println(file);

    }

}

3、相对路径和绝对路径

    相对路径： 是一个简单的路径， 相对路径在idea中相对的是当前的项目。 指的是当前项目下的东西。

              相对路径的特点是这个路径不是从盘符开始的。  比如： aa.txt

    绝对路径： 是一个完整的路径， 绝对路径是从盘符开始的。 比如： d:\aa.txt  e:\b\c\aa.txt

public class Demo03Path {

    public static void main(String[] args) {

        File file = new File("day08\\aa.txt");

    }

}

4、 File中的判断方法

        boolean exists()：判断File对象所表示的文件或者文件夹是否存在

        boolean isFile()：判断File对象所表示的是否是一个文件

        boolean isDirectory()： 判断File对象所表示的是否是文件夹.

public class Demo04FileMethod {

    public static void main(String[] args) {

        method3();

    }

 

    //boolean isDirectory()： 判断File对象所表示的是否是文件夹.

    public static void method3() {

        //创建File对象

        //File file = new File("d:\\iotest\\aa.txt");

        //File file = new File("d:\\iotest\\bb");

        File file = new File("d:\\iotest\\zz");

        //判断是否是一个文件夹

        boolean flag = file.isDirectory();

        System.out.println("flag:" + flag);

    }

 

 

    //boolean isFile()：判断File对象所表示的是否是一个文件

    public static void method2() {

        //创建一个File对象

        //File file = new File("d:\\iotest\\aa.txt");

        //File file = new File("d:\\iotest\\bb");

        File file = new File("d:\\iotest\\zz");

        boolean flag = file.isFile();

        System.out.println("flag:" + flag);

    }

 

    //boolean exists()：判断File对象所表示的文件或者文件夹是否存在

    public static void method1() {

        //创建一个File对象

        //File file = new File("d:\\iotest\\aa.txt");

        File file = new File("d:\\iotest\\zz.txt");

 

        boolean flag = file.exists();

        System.out.println("flag:" + flag);

    }

}

 

5、File中的创建方法

        boolean createNewFile()：创建一个文件，如果文件已经存在则创建失败。

        boolean mkdir()：创建文件夹，如果文件夹已经存在则创建失败。 只能创建单级目录

        （推荐）boolean mkdirs()：创建文件夹，如果文件夹已经存在则创建失败。 可以创建多级。

public class Demo05FileMethod {

    public static void main(String[] args) throws IOException {

        method3();

    }

 

    //boolean mkdirs()：创建文件夹，如果文件夹已经存在则创建失败。

    //如果上级目录不存在，那么会一起创建上级目录

    public static void method3() {

        //创建一个File对象

        //File file = new File("d:\\iotest\\cc");

        File file = new File("d:\\iotest1\\cc");

        //调用file的mkdirs创建一个File对象

        boolean flag = file.mkdirs();

        System.out.println("flag:" + flag);

    }

 

    //boolean mkdir()：创建文件夹，如果文件夹已经存在则创建失败。

    //使用mkdir创建文件夹时，如果上级目录不存在，那么则创建失败返回false。

    public static void method2() {

        //创建一个File对象

        //File file = new File("d:\\iotest\\bb");

        //File file = new File("d:\\iotest\\cc.txt");

        File file = new File("d:\\iotest1\\aa.txt");

        boolean flag = file.mkdir();

        System.out.println("flag:" + flag);

 

    }

 

    //boolean createNewFile()：创建一个文件，如果文件已经存在则创建失败。

    //如果创建文件时，上级目录不存在，那么则会抛出异常

    public static void method1() throws IOException {

        //创建一个File对象

        //File file = new File("d:\\iotest\\aa.txt");

        //File file = new File("d:\\iotest\\新建文件夹");

        File file = new File("d:\\iotest1\\aa.txt");

        //调用createNewFile创建该文件

        boolean flag = file.createNewFile();

        System.out.println("flag:" + flag);

    }

}

6、 File中的删除方法

        boolean delete()：删除此File对象表示的文件或者文件夹

    如果删除的是一个文件夹，那么只能删除空文件夹，如果里面有东西是无法删除的。

    【调用delete删除的内容不走回收站】

public class Demo06FileMethod {

    public static void main(String[] args) {

        //创建一个File对象

        //File file = new File("d:\\iotest\\aa.txt");

        //File file = new File("d:\\iotest\\bb");

        File file = new File("F:\\pucture");

        //调用delete方法，删除这个文件

        boolean flag = file.delete();

        System.out.println("flag:" + flag);

    }

}

7、File中的遍历方法

        String[] list()： 获取指定文件夹中所有的内容(文件和文件夹)，返回String数组

        （非常重要）File[] listFiles()： 获取指定文件夹中所有的内容（文件和文件）， 返回File数组

public class Demo07FileMethod {

    public static void main(String[] args) {

        method3();

    }

    /*

        注意：

        如果file对象表示的文件夹里面没有任何内容，调用listFiles得到的结果是空数组  File[] files = {};

        如果file对象表示的是文件，那么调用listFiles得到的结果是一个null。

        如果file对象表示的路径不存在，调用listFiles得到的结果会是 null

     */

    public static void method3() {

        //创建File对象

        File file = new File("d:\\bb");

        //获取此file对象下面的所有文件和文件夹

        File[] files = file.listFiles();

 

        System.out.println(files);

    }

 

    /*

        File[] listFiles()： 获取指定文件夹中所有的内容（文件和文件）， 返回File数组

     */

    public static void method2() {

        //创建File对象

        File file = new File("d:\\iotest");

        //调用listFiles方法，获取该文件夹中所有的文件和文件夹

        File[] files = file.listFiles();

        //遍历这个数组，拿到这个数组中的每个File对象

        for(File thisFile : files) {

            System.out.println(thisFile);

        }

    }

 

    /*

        String[] list()： 获取指定文件夹中所有的内容(文件和文件夹)，返回String数组。

        这个方法真正获取到的是文件或者文件夹的名字，然后放入到了String数组.

     */

    public static void method1() {

        //创建一个File对象

        File file = new File("d:\\iotest");

        //调用list方法，获取此file对象所表示文件夹下面的所有内容

        String[] strArr = file.list();

        //增强for遍历这个数组

        for(String str : strArr) {

            System.out.println(str);

        }

    }

}

二、递归

 

1、 递归指的是方法直接或者间接的调用方法本身。

    两种递归方式：

        1. 直接递归：methodA -> methodA

        2. 间接递归：methodA -> methodB -> methodC -> methodA

    递归的注意事项：

        1. 递归一定要有结束条件（出口）  （会栈内存溢出）

        2. 递归次数不能太多 （会栈内存溢出）

public class Demo01DiGui {

    public static void main(String[] args) {

        //method();

        //methodA();

        printNum(1);

    }

 

    //定义方法，用来打印变量

    public static void printNum(int num) {

        //加入判断，如果num是2000，那么就直接结束这个方法。

        if (num == 20000) {

            return; //方法遇到return直接结束

        }

 

        System.out.println(num);

        num++;

        printNum(num);

    }

 

    public static void methodA() {

        System.out.println("methodA...");

        methodB();

    }

 

    public static void methodB() {

        System.out.println("methodB...");

        methodC();

    }

 

    public static void methodC() {

        System.out.println("methodC...");

        methodA();

    }

 

    public static void method() {

        System.out.println("method...");

        method();

    }

}

 

2、递归的案例

（1）递归求指定数的阶乘

public class Demo02DiGuiTest {

    public static void main(String[] args) {

        int result = getJieCheng(5);

        System.out.println(result);

    }

 

    /*

        定义一个方法，求指定数字的阶乘

        获取到参数num的阶乘并返回结果

     */

    public static int getJieCheng(int num) {

        //如果num是1，那么1的阶乘就是固定值1

        if(num == 1) {

            return 1;

        }

        //如果是其他情况。 这个数的阶乘 = 这个数 * (这个数-1的阶乘)

        return num * getJieCheng(num - 1);

    }

}

（2）递归求指定数的累加和

public class Demo03DiGuiTest {

    public static void main(String[] args) {

        int sum = getSum(100);

        System.out.println("sum:" + sum);

    }

    /*

        用来求指定数字的累加和并且返回

     */

    public static int getSum(int num) {

       //判断要求的数是不是以，如果是1，1的累加和就是固定值1.直接返回1

        if(num == 1) {

            return 1;

        }

        //如果是其他情况， 这个数的累加和 = 这个数 + 前一个数的累加和

        return num + getSum(num - 1);

    }

}

 

3、递归遍历打印多级目录

public class Demo04DigGuiTest {

    public static void main(String[] args) {

        printDir(new File("d:\\明星"));

    }

 

    /*

        定义方法，用来遍历打印指定目录中的所有的文件

        参数： 要打印的目录

     */

    public static void printDir(File dir) {

        //获取该目录中所有的内容

        File[] files = dir.listFiles();

        //遍历数组，打印里面的每一个元素

        for(File thisFile : files) {

            //判断当前遍历到的是否是一个文件夹，如果是文件夹，我们可以继续获取这个文件夹中的内容。

            //如果遍历到的是一个文件，那么我们就可以直接打印文件的名字

            if(thisFile.isDirectory()) {

                //如果是文件夹，那么就获取这个文件夹中所有的内容。

                //printDir2(thisFile);

                printDir(thisFile);

            } else {

                //否则表示这是一个文件，那么就直接打印文件名

                System.out.println(thisFile.getName());

            }

        }

    }

 

 

 

    public static void printDir2(File dir) {

        //如果是文件夹，那么就获取这个文件夹中所有的内容。

        File[] files2 = dir.listFiles();

        //遍历打印这个文件夹下面的内容

        for(File thisFile2 : files2) {

            //判断当前遍历到的File对象是否是文件夹，如果是文件夹，那么继续遍历这个文件夹中的内容。

            //如果遍历到的是一个文件，那么就可以直接打印文件名

            if(thisFile2.isDirectory()) {

                //如果是文件夹，那么继续遍历这个文件夹中的内容。

                printDir3(thisFile2);

            } else {

                //否则是一个文件，那么就可以直接打印文件名

                System.out.println(thisFile2.getName());

            }

        }

    }

 

    public static void printDir3(File dir) {

        //如果是文件夹，那么继续遍历这个文件夹中的内容。

        File[] files3 = dir.listFiles();

        //遍历这个数组，然后直接打印

        for(File thisFile3 : files3) {

            System.out.println(thisFile3.getName());

        }

    }

}

 

4、过滤器的使用

 （1）FileFilter表示过滤器，所以当一个类实现了这个接口这个类也就变成了过滤器

 （2）使用步骤

如果调用listFiles方法的时候想要过滤掉自己不想要的内容，那么可以使用过滤器。

        File[] listFiles(FileFilter filter)： 传递一个过滤器对象，能够根据过滤器的规则过滤掉不想要的内容

    FileFilter是一个接口，表示过滤器， 里面有一个方法accept，用来定义规则

        boolean accept(File pathname)： 返回值为true表示该对象留下，如果返回值为false表示该对象被过滤掉。

    过滤器的使用步骤：

        1. 定义一个类，实现FileFilter接口，并且重写accept方法，定义过滤规则。

        2. 创建File对象，并且调用listFiles方法传递FileFilter实现类对象。

        3. 遍历File数组，打印每一个file对象

public class Demo02Filter {

    public static void main(String[] args) {

        //创建file对象

        File file = new File("d:\\iotest");

        //调用listFiles方法

        File[] files = file.listFiles(new MyFileFilter());

 

        for (File thisFile : files) {

            System.out.println(thisFile.getName());

        }

    }

}

 

package cn.itcast.demo03;

 

import java.io.File;

 

/*

    搜索 D:\aaa 目录中的 .java 文件

 

    打印D:\aaa 目录中所有.java文件的绝对路径

 

 

*/

public class Demo01Test {

    public static void main(String[] args) {

        printJavaFile(new File("d:\\aaa"));

    }

 

    /*

        定义方法，用来检索指定目录下面的所有.java文件

        获取参数dir中所有的.java文件的绝对路径并打印.

 

        步骤：

            1. 获取dir文件夹中所有的文件和文件夹，放入到一个File数组

            2. 遍历这个File数组， 拿到里面的每一个文件或文件夹

            3. 判断，如果遍历到的是一个文件夹，那么继续递归调用当前方法，获取这个文件夹中的所有.java并且打印

                     如果遍历到的是一个文件，那么就判断是否以.java结尾，如果是以.java结尾，那么就打印绝对路径

     */

    public static void printJavaFile(File dir) {

        //获取dir文件夹中所有的文件和文件夹，放入到一个File数组

        File[] files = dir.listFiles();

        //遍历这个File数组， 拿到里面的每一个文件或文件夹

        for(File thisFile : files) {

            //判断，如果遍历到的是一个文件夹，那么继续递归调用当前方法，获取这个文件夹中的所有.java并且打印

            if(thisFile.isDirectory()) {

                printJavaFile(thisFile);

            } else {

                //如果遍历到的是一个文件，那么就判断是否以.java结尾，如果是以.java结尾，那么就打印绝对路径

                if(thisFile.getName().endsWith(".java")) {

                    System.out.println(thisFile.getAbsolutePath());

                }

            }

        }

    }

}

 

 

package cn.itcast.demo03;

 

import java.io.File;

import java.io.FileFilter;

 

/*

    打印d:\aaa文件夹中所有的java文件的绝对路径。

 

    使用过滤器

*/

public class Demo03Test {

    public static void main(String[] args) {

        printPath(new File("d:\\aaa"));

    }

    /*

        定义方法，打印指定目录中的所有的java文件

     */

 

    //Lambda表达式版本

 

    public static void printPath(File dir) {

        //listFiles方法参数需要一个FileFilter接口类型的参数，所以可以以匿名内部类的方式创建对象

        //匿名内部类的简化写法可以写成Lambda表达式

        File[] files = dir.listFiles(pathname -> {

            //.java结尾的文件留下

            if (pathname.isFile() && pathname.getName().endsWith(".java")) {

                return true;

            }

            //文件夹也留下

            if (pathname.isDirectory()) {

                return true;

            }

            //其他的都过滤掉

            return false;

        });

        for(File thisFile : files) {

            if(thisFile.isDirectory()) {

                printPath(thisFile);

            } else {

                System.out.println(thisFile.getAbsolutePath());

            }

        }

    }

 

 

    //匿名内部类版本

    /*

    public static void printPath(File dir) {

        //listFiles方法参数需要一个FileFilter接口类型的参数，所以可以以匿名内部类的方式创建对象

        File[] files = dir.listFiles(new FileFilter() {

            @Override

            public boolean accept(File pathname) {

                //.java结尾的文件留下

                if (pathname.isFile() && pathname.getName().endsWith(".java")) {

                    return true;

                }

                //文件夹也留下

                if (pathname.isDirectory()) {

                    return true;

                }

                //其他的都过滤掉

                return false;

            }

        });

        for(File thisFile : files) {

            if(thisFile.isDirectory()) {

                printPath(thisFile);

            } else {

                System.out.println(thisFile.getAbsolutePath());

            }

        }

    }*/

 

 

 

 

    /*

    public static void printPath(File dir) {

        //调用该文件夹的listFiles方法，获取该文件夹中的所有的内容

        //因为我们只需要获取所有的java文件，所以可以使用过滤器过滤掉不想要的内容

        File[] files = dir.listFiles(new MyJavaFilter());

        //遍历数组，拿到数组中的每一个文件或者文件夹

        for(File thisFile : files) {

            //如果遍历到的是一个文件夹，那么我们就继续递归调用该方法，获取该文件夹中的所有.java文件

            if(thisFile.isDirectory()) {

                printPath(thisFile);

            } else {

                //如果是一个文件，那么就直接打印（因为过滤器已经过滤了，留下 来的文件都是.java的）

                System.out.println(thisFile.getAbsolutePath());

            }

        }

    }

    */

}

 

 

package cn.itcast.demo03;

 

import java.io.File;

import java.io.FileFilter;

/*

    FileFilter表示过滤器，所以当一个类实现了这个接口这个类也就变成了过滤器

*/

public class MyFileFilter implements FileFilter{

    /*

        参数pathname： 表示将来要过滤的每一个File对象

        返回值： 如果返回值是true刚表示这个对象留下，如果返回值是false，表示这个对象过滤掉

 

        过滤规则，只留下.java结尾的文件。其他的都不要

     */

    @Override

    public boolean accept(File pathname) {

        if(pathname.isFile() && pathname.getName().endsWith(".java")) {

            return true;

        }

        return false;

    }

}