​java学习day19（File类和IO流）File类、递归

最新推荐文章于 2022-10-24 21:39:52 发布
最新推荐文章于 2022-10-24 21:39:52 发布
阅读量150 收藏
点赞数
文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaosong0623/article/details/125356546
版权

前言：

所谓file类就是一个对文件和目录进行增删改查操作的类，存在于java.io 库中，该库提供了通过数据流、序列化和文件系统提供系统输入和输出。

而递归让我想起了武林外传中的那句经典台词，我杀了我自己。

所谓递归就是在执行操作的时候自己对自己调用，其中又分为直接调用和间接调用，只是方法不同，但是实现的目的都一样。

今天我们将主要进行这两部分的学习。

今日重点：

  • File类

  • 递归

文章索引：

File类

概述

File类的静态成员变量

 绝对路径和相对路径

构造方法

常用方法

获取功能的方法

判断功能的方法

创建删除功能的方法

目录的遍历

递归

概述

递归累加求和

计算1 ~ n的和

递归求阶乘

递归打印多级目录

文件搜索

文件过滤器优化

Lambda优化

File类

概述

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

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

重点:记住这三个单词
    file:文件
    directory:文件夹/目录
    path:路径

File类的静态成员变量

 

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

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

操作路径:路径不能写死了
C:\develop\a\a.txt  windows
C:/develop/a/a.txt  linux
"C:"+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt"

使用示例：

public class Demo01File {
    public static void main(String[] args) {
        String pathSeparator = File.pathSeparator;
        System.out.println(pathSeparator);//路径分隔符 windows:分号;  linux:冒号:

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

}

 绝对路径和相对路径

路径:
    绝对路径:是一个完整的路径
        以盘符(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(可以省略项目的根目录)
    注意:
        1.路径是不区分大小写
        2.路径中的文件名称分隔符windows使用反斜杠,反斜杠是转义字符,两个反斜杠代表一个普通的反斜杠 

构造方法

  • public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。

  • public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。

  • public File(File parent, String child) ：从父抽象路径名和子路径名字符串创建新的 File实例。

public class Demo02File {
    public static void main(String[] args) {
        /*
            File类的构造方法
         */
        //show02("c:\\","a.txt");//c:\a.txt
        //show02("d:\\","a.txt");//d:\a.txt
        show03();

        File f = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan");
        long length = f.length();
        System.out.println(length);
    }

    /*
        File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
        参数:把路径分成了两部分
            File 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);//c:\hello.java
    }

    /*
        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(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
        参数:
            String pathname:字符串的路径名称
            路径可以是以文件结尾,也可以是以文件夹结尾
            路径可以是相对路径,也可以是绝对路径
            路径可以是存在,也可以是不存在
            创建File对象,只是把字符串路径封装为File对象,不考虑路径的真假情况
     */
    private static void show01() {
        File f1 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\a.txt");
        System.out.println(f1);//重写了Object类的toString方法 C:\Users\itcast\IdeaProjects\shungyuan\a.txt

        File f2 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan");
        System.out.println(f2);//C:\Users\itcast\IdeaProjects\shungyuan

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

常用方法

获取功能的方法

  • public String getAbsolutePath() ：返回此File的绝对路径名字符串。

  • public String getPath() ：将此File转换为路径名字符串。

  • public String getName() ：返回由此File表示的文件或目录的名称。

  • public long length() ：返回由此File表示的文件的大小。

示例代码：

public class Demo03File {
    public static void main(String[] args) {
        show04();
    }

    /*
        public long length()  ：返回由此File表示的文件的长度。
        获取的是构造方法指定的文件的大小,以字节为单位
        注意:
            文件夹是没有大小概念的,不能获取文件夹的大小
            如果构造方法中给出的路径不存在,那么length方法返回0
     */
    private static void show04() {
        File f1 = new File("C:\\develop\\a\\1.jpg");
        long l1 = f1.length();
        System.out.println(l1);//780831字节

        File f2 = new File("C:\\develop\\a\\2.jpg");
        System.out.println(f2.length());//0

        File f3 = new File("C:\\develop\\a");
        System.out.println(f3.length());//0 文件夹没有大小概念的
    }

    /*
        public String getName()  ：返回由此File表示的文件或目录的名称。
        获取的就是构造方法传递路径的结尾部分(文件/文件夹)
     */
    private static void show03() {
        File f1 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\a.txt");
        String name1 = f1.getName();
        System.out.println(name1);//a.txt

        File f2 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan");
        String name2 = f2.getName();
        System.out.println(name2);//shungyuan
    }

    /*
        public String getPath() ：将此File转换为路径名字符串。
        获取的构造方法中传递的路径

        toString方法调用的就是getPath方法
        源码:
            public String toString() {
                return getPath();
            }
     */
    private static void show02() {
        File f1 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\a.txt");
        File f2 = new File("a.txt");
        String path1 = f1.getPath();
        System.out.println(path1);//C:\Users\itcast\IdeaProjects\shungyuan\a.txt
        String path2 = f2.getPath();
        System.out.println(path2);//a.txt

        System.out.println(f1);//C:\Users\itcast\IdeaProjects\shungyuan\a.txt
        System.out.println(f1.toString());//C:\Users\itcast\IdeaProjects\shungyuan\a.txt
    }

    /*
        public String getAbsolutePath() ：返回此File的绝对路径名字符串。
        获取的构造方法中传递的路径
        无论路径是绝对的还是相对的,getAbsolutePath方法返回的都是绝对路径
     */
    private static void show01() {
        File f1 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\a.txt");
        String absolutePath1 = f1.getAbsolutePath();
        System.out.println(absolutePath1);//C:\Users\itcast\IdeaProjects\shungyuan\a.txt

        File f2 = new File("a.txt");
        String absolutePath2 = f2.getAbsolutePath();
        System.out.println(absolutePath2);//C:\Users\itcast\IdeaProjects\shungyuan\a.txt
    }
}

判断功能的方法

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

  • public boolean isDirectory() ：此File表示的是否为目录。

  • public boolean isFile() ：此File表示的是否为文件。

示例代码：

public class Demo04File {
    public static void main(String[] args) {
        show02();
    }

    /*
        public boolean isDirectory() ：此File表示的是否为目录。
            用于判断构造方法中给定的路径是否以文件夹结尾
                是:true
                否:false
        public boolean isFile() ：此File表示的是否为文件。
            用于判断构造方法中给定的路径是否以文件结尾
                是:true
                否:false
        注意:
            电脑的硬盘中只有文件/文件夹,两个方法是互斥
            这两个方法使用前提,路径必须是存在的,否则都返回false
     */
    private static void show02() {
        File f1 = new File("C:\\Users\\itcast\\IdeaProjects\\shung");

        //不存在,就没有必要获取
        if(f1.exists()){
            System.out.println(f1.isDirectory());
            System.out.println(f1.isFile());
        }

        File f2 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan");
        if(f2.exists()){
            System.out.println(f2.isDirectory());//true
            System.out.println(f2.isFile());//false
        }

        File f3 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\shungyuan.iml");
        if(f3.exists()){
            System.out.println(f3.isDirectory());//false
            System.out.println(f3.isFile());//true
        }
    }

    /*
        public boolean exists() ：此File表示的文件或目录是否实际存在。
        用于判断构造方法中的路径是否存在
            存在:true
            不存在:false
     */
    private static void show01() {
        File f1 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan");
        System.out.println(f1.exists());//true

        File f2 = new File("C:\\Users\\itcast\\IdeaProjects\\shung");
        System.out.println(f2.exists());//false

        File f3 = new File("shungyuan.iml");//相对路径 C:\Users\itcast\IdeaProjects\shungyuan\shungyuan.iml
        System.out.println(f3.exists());//true

        File f4 = new File("a.txt");
        System.out.println(f4.exists());//false
    }
}

创建删除功能的方法

  • public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。

  • public boolean delete() ：删除由此File表示的文件或目录。

  • public boolean mkdir() ：创建由此File表示的目录。

  • public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。

示例代码：

public class Demo05File {
    public static void main(String[] args) throws IOException {
        show03();
    }

    /*
        public boolean delete() ：删除由此File表示的文件或目录。
        此方法,可以删除构造方法路径中给出的文件/文件夹
        返回值:布尔值
            true:文件/文件夹删除成功,返回true
            false:文件夹中有内容,不会删除返回false;构造方法中路径不存在false
        注意:
            delete方法是直接在硬盘删除文件/文件夹,不走回收站,删除要谨慎
     */
    private static void show03() {
        File f1 = new File("08_FileAndRecursion\\新建文件夹");
        boolean b1 = f1.delete();
        System.out.println("b1:"+b1);

        File f2 = new File("08_FileAndRecursion\\abc.txt");
        System.out.println(f2.delete());
    }

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

        File f2 = new File("08_FileAndRecursion\\111\\222\\333\\444");
        boolean b2 = f2.mkdirs();
        System.out.println("b2:"+b2);

        File f3 = new File("08_FileAndRecursion\\abc.txt");
        boolean b3 = f3.mkdirs();//看类型,是一个文件
        System.out.println("b3:"+b3);

        File f4 = new File("08_F\\ccc");
        boolean b4 = f4.mkdirs();//不会抛出异常,路径不存在,不会创建
        System.out.println("b4:"+b4);
    }

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

        public boolean createNewFile() throws IOException
        createNewFile声明抛出了IOException,我们调用这个方法,就必须的处理这个异常,要么throws,要么trycatch
     */
    private static void show01() throws IOException {
        File f1 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\08_FileAndRecursion\\1.txt");
        boolean b1 = f1.createNewFile();
        System.out.println("b1:"+b1);

        File f2 = new File("08_FileAndRecursion\\2.txt");
        System.out.println(f2.createNewFile());

        File f3 = new File("08_FileAndRecursion\\新建文件夹");
        System.out.println(f3.createNewFile());//不要被名称迷糊,要看类型

        File f4 = new File("08_FileAndRecursi\\3.txt");
        System.out.println(f4.createNewFile());//路径不存在,抛出IOException
    }
}

目录的遍历

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

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

注意:
    list方法和listFiles方法遍历的是构造方法中给出的目录
    如果构造方法中给出的目录的路径不存在,会抛出空指针异常
    如果构造方法中给出的路径不是一个目录,也会抛出空指针异常

代码示例：

public class Demo06File {
    public static void main(String[] args) {
        show02();
    }

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

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

递归

概述

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

示例代码：

public class Demo01Recurison {
    public static void main(String[] args) {
        //a();
        b(1);
    }

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

    /*
            在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
            11157
                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();
    }
}

示意图：

递归累加求和

计算1 ~ n的和

实现代码：

public class Demo02Recurison {
    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);
    }
}

示意图：

递归求阶乘

练习:
    使用递归计算阶乘
    n的阶乘：n! = n * (n-1) *...* 3 * 2 * 1

public class Demo03Recurison {
    public static void main(String[] args) {
        int jiecheng = jc(5);
        System.out.println(jiecheng);
    }

    /*
        定义方法使用递归计算阶乘
        5的阶乘: 5! = 5*(5-1)*(5-2)*(5-3)*(5-4)=5*4*3*2*1
        递归结束的条件
            获取到1的时候结束
        递归的目的
            获取下一个被乘的数字(n-1)
        方法的参数发生变化
            5,4,3,2,1
     */
    public static int jc(int n){
        //获取到1的时候结束
        if(n==1){
            return 1;
        }
        //获取下一个被乘的数字(n-1)
        return n * jc(n-1);
    }
}

递归打印多级目录

练习:
    递归打印多级目录
需求:
    遍历c:\\abc文件夹,及abc文件夹的子文件夹
    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

示例代码： 

public class Demo04Recurison {
    public static void main(String[] args) {
        File file = new File("c:\\abc");
        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方法就是传递文件夹,遍历文件夹的方法
                //所以直接调用getAllFile方法即可:递归(自己调用自己)
                getAllFile(f);
            }else{
                //f是一个文件,直接打印即可
                System.out.println(f);
            }
        }
    }
}

示意图：

文件搜索

需求:
    遍历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

示例代码：

 

public class Demo05Recurison {
    public static void main(String[] args) {
        File file = new File("c:\\abc");
        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方法就是传递文件夹,遍历文件夹的方法
                //所以直接调用getAllFile方法即可:递归(自己调用自己)
                getAllFile(f);
            }else{
                //f是一个文件,直接打印即可
                /*
                    c:\\abc\\abc.java
                    只要.java结尾的文件
                    1.把File对象f,转为字符串对象
                 */
                //String name = f.getName();//abc.java
                //String path = f.getPath();//c:\\abc\\abc.java
                //String s = f.toString();//c:\\abc\\abc.java

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

                //2.调用String类中的方法endsWith判断字符串是否是以.java结尾
                //boolean b = s.endsWith(".java");

                //3.如果是以.java结尾的文件,则输出
                /*if(b){
                    System.out.println(f);
                }*/

                if(f.getName().toLowerCase().endsWith(".java")){
                    System.out.println(f);
                }
            }
        }
    }
}

文件过滤器优化

需求:
    遍历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,在方法中自己定义过滤的规则

示意图：

 示例代码：

public class Demo01Filter {
    public static void main(String[] args) {
        File file = new File("c:\\abc");
        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方法就是传递文件夹,遍历文件夹的方法
                //所以直接调用getAllFile方法即可:递归(自己调用自己)
                getAllFile(f);
            }else{
                //f是一个文件,直接打印即可
                System.out.println(f);
            }
        }
    }
}

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

/*
    创建过滤器FileFilter的实现类,重写过滤方法accept,定义过滤规则
 */
public class FileFilterImpl implements FileFilter{
    @Override
    public boolean accept(File pathname) {
        /*
            过滤的规则:
            在accept方法中,判断File对象是否是以.java结尾
            是就返回true
            不是就返回false
         */
        //如果pathname是一个文件夹,返回true,继续遍历这个文件夹
        if(pathname.isDirectory()){
            return true;
        }

        return pathname.getName().toLowerCase().endsWith(".java");
    }
}

Lambda优化

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

public class Demo02Filter {
    public static void main(String[] args) {
        File file = new File("c:\\abc");
        getAllFile(file);
    }

    /*
        定义一个方法,参数传递File类型的目录
        方法中对目录进行遍历
     */
    public static void getAllFile(File dir){
        //传递过滤器对象 使用匿名内部类
        /*File[] files = dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                //过滤规则,pathname是文件夹或者是.java结尾的文件返回true
                return pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java");
            }
        });*/

        //使用Lambda表达式优化匿名内部类(接口中只有一个抽象方法)
        /*File[] files = dir.listFiles((File pathname)->{
            return pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java");
        });*/

        File[] files = dir.listFiles(pathname->pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java"));

        /*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表达式优化匿名内部类(接口中只有一个抽象方法)
        /*File[] files = dir.listFiles((File d, String name)->{
            //过滤规则,pathname是文件夹或者是.java结尾的文件返回true
            return new File(d,name).isDirectory() || name.toLowerCase().endsWith(".java");
        });*/

        //File[] files = dir.listFiles((d,name)->new File(d,name).isDirectory() || name.toLowerCase().endsWith(".java"));

        for (File f : files) {
            //对遍历得到的File对象f进行判断,判断是否是文件夹
            if(f.isDirectory()){
                //f是一个文件夹,则继续遍历这个文件夹
                //我们发现getAllFile方法就是传递文件夹,遍历文件夹的方法
                //所以直接调用getAllFile方法即可:递归(自己调用自己)
                getAllFile(f);
            }else{
                //f是一个文件,直接打印即可
                System.out.println(f);
            }
        }
    }
}

Andy393939
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
[史上最全] 文件处理工具类 java版 处理文件流, 文件目录递归等
09-15
一个公共的文件处理类, 包含大大小小50多个方法, 不用自己处理连接池问题,不用自己关闭文件流, 非常方便, 我一直都用这个类
【JAVA 学习笔记】File类、递归
lameraaa的博客
09-03 161
【File类、递归】 文章目录【File类、递归】第一章 File类绝对路径和相对路径1.2 构造方法1.3 常用方法获取功能的方法判断功能的方法创建删除功能的方法1.4 目录的遍历第二章 递归2.1 概述2.2 递归打印多级目录第三章 综合案例3.1 文件搜索3.2 文件过滤器优化3.3 Lambda优化 第一章 File类 java.io.File 类是文件和目录路径名的抽象表示，主要用于文件...
Java递归建创建文件，解决目录不存在创建文件报错的问题
xxx
11-13 2005
递归建文件即可，代码如下 public static void createFileRecursion(String fileName, Integer height) throws IOException { Path path = Paths.get(fileName); if (Files.exists(path)) { // TODO: 2021/11/13 如果文件存在 return; }
java 边读边写文件_文件操作--边读边写,在指定位置添加内容(避免乱码)
weixin_39579548的博客
02-13 1909
[java]代码库/*** @param lineNumber 选择要添加内容的行数* @param attribute1 选择要添加的内容1* @param attribute2 选择要添加的内容1* 给finalFile,tempFilePath改成你自己的路径就可以用了*/public static void appendText(int lineNumbe...
java 循环创建文件_java File基本操作，以及递归遍历文件夹
weixin_30983353的博客
02-12 1473
java 的文件操作，相对来说是比较重要的，无论是编写CS还是BS程序，都避免不了要与文件打交道，例如读写配置文件等。虽然现在很多框架都直接帮你做好了这一步！java.io.File 底层是调用与c语言接的接口，所以我们暂时不需要知道底层是怎么实现的，再说了，也看不见，最多就是看见一个接口而已。我们只需要知道java.io.File提供给我们对文件的一些操作就行了。1.文件的创建：java的文件创...
递归创建文件夹或文件
weixin_44819874的博客
09-10 1855
最近有个场景，目录不存在时要去创建，但问题是目录可能为多级的且都不存在，解决的代码如下： public static void createtDir(String filePath) { String[] paths = {""}; //切割路径 try { String tempPath = new File(filePath).getCanonicalPath(); //windows
Test File递归删除.java
10-14
File类操作递归删除 大型文件秒删 无法找回 千万不要删系统盘
day19_阻塞队列、线程池、File类、递归.pdf
11-02
day19_阻塞队列、线程池、File类、递归.pdf
java TreeUtil菜单递归工具类
09-07
主要为大家详细介绍了java TreeUtil菜单递归工具类，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
day08【File类、递归】-笔记1
08-04
第一章 File类1.1 概述java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。1.2 构造方法public
使用递归生成文件目录树
12-16
使用递归生成文件目录树 .txt 使用递归生成文件目录树 .txt
java 递归生成目录
lsh009的专栏
04-07 801
package com.test; import java.io.File; public class DirRecursion { // mkdirs() public static void mkDir(File file) { if (file.getParentFile().exists()) { file.mkdir(); } else { mkDir(file
java文件递归_java递归处理文件夹和文件
weixin_42467411的博客
02-20 140
import java.io.File;/*** 文件综合使用示例*/public class FileDelete {public static void main(String[] args) {File f = new File("d:\\test");printAllFile(f);File f1 = new File("d:\\test");deleteAll(f1);}/*** 打印f...
java基础-递归操作文件夹
qq_41044340的博客
06-11 205
java基础-递归操作文件夹前言递归打印结果结语 前言 今天看视频，学了一个递归操作，发现递归对文件操作特备方便，故自己码了一遍代码，做此记录。 递归 大家都知道，递归就是自己调用自己，有一个递归头和一个体，如果没有头，程序将无法结束循环，从而导致死循环。 话不多说，直接上代码。 package test; import java.io.File; public class Test { p...
java 创建文件夹多层,Java笔记之io——递归创建与删除多层文件夹，字符流实现文件复制...
weixin_35683252的博客
03-14 541
学了io流这一节后想到了一个问题，就是如何实现用递归实现逐级创建多层文件夹。当然，也可以创建文件，ps本文没有创文件创建：主要是用递归调用，每次调用的时候利用file.getAbsolutePath() 返回当前文件夹路径名称拼接，然后组合成新路径，递归删除：同样是利用递归，首先通过 FIle list[] =path.listFile();然后再遍历调用至于文件复制，其实就是讲一个文件用字符流(...
Java-File类、递归-第19节
zuefeng的博客
10-13 261
学习目标： 熟练使用File类，能够实现创建与删除文件文件夹操作； 掌握常用的搜索文件夹或者文件的方法； 理解递归的概念，并熟练使用递归完成搜索工作。 学习内容： 一、File类 1、简介 a、java.io.File b、对文件或文件夹（目录）的封装类 2、主要功能 a、创建文件、文件夹 b、删除文件、文件夹 c、查找文件、文件夹 d、判断是否存在文件、文件夹 e、遍历文件夹（目录） f、获取文件的大小 3、静态成员变量 a、pathSeparator - Static Str
java类file实现文件递归查找指定文件名后缀，过滤器
weixin_40228600的博客
10-24 1012
java类file实现文件递归查找指定文件名后缀，过滤器
Day16_8 Java学习之File类与递归
weixin_43717536的博客
08-16 515
解析：1.在Java中，File 类是 java.io 包中唯一代表磁盘文件本身的对象，也就是说，如果希望在程序中操作文件和目录，则都可以通过 File 类来完成。2.File 类定义了一些方法来操作文件，如新建、删除、重命名文件和目录等。3.File类就是描述文件或文件夹的，只要我们在Java中要操作文件或文件夹，就找File类。...
Java：实现目录递归工具类
Rex Chou的技术博客
03-17 935
假设一下，如果你想用代码删除某个文件夹，而这个文件夹下有很多的文件夹和文件。 但是File类的delete方法，要么只能删除一个文件，要么只能删除一个空文件夹。 所以就要用目录递归的办法，把文件夹里面的东西逐个删除。 并且你大概率不仅仅需要删除文件夹的功能，你可能还想要能搜索目录中的文件、获取目录中的文件个数等等的需求，这些功能都需要目录递归。 本文旨在用简练的代码提供一个易维护、易扩展的基础版的目录操作工具类，至于其中未完善的部分可由君来自行完善和扩展。 首先创建一个DirTreeAction接口， 实现
java file类删除文件夹
最新发布
11-22
2. 然后可以使用Files类的静态方法delete(Path path)来删除文件夹，但是该方法只能删除空文件夹，如果要删除非空文件夹，需要先递归删除文件夹中的所有文件和子文件夹，然后再删除该文件夹，例如： ```java public ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Andy393939

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值