java File类、递归的详细介绍

最新推荐文章于 2024-01-20 09:00:00 发布

王胖子总叫我减肥

最新推荐文章于 2024-01-20 09:00:00 发布

阅读量99

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/weixin_45519487/article/details/105691136

版权

Java 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

1.File类

1.1 概述：

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

1.2 构造方法

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

public File（String parent，String child）：从父路径名字符串和子路径名字符串来创建新的File实例。

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

public class Demo {
    public static void main(String[] args) {
        //文件路径名
        String pathname="D:\\aaa.txt";
        File file1=new File(pathname);
        //文件路径名
        String pathname1="D:\\aaa\\bbb.txt";
        File file2=new File(pathname1);
        //通过父路径名和子路经字符串
        String parent="d:\\aaa";
        String child="bbb.txt";
        File file3=new File(parent,child);
        //通过父抽象路径名和字路径名
        File parentDir=new File("d:\\aa");
        String child1="bbb.txt";
        File file4=new File(parentDir,child1);
    }
}

注：一个File对象代表硬盘中实际存在的一个文件或者目录。无论该路径下是否存在文件或者目录，都不影响File对象的创建。

1.3 常用方法

获取功能的方法：

public String getAbsolutePatn():返回此File的绝对路径名字符串。

public String getPath（）：将此File转换为路径名字符串。

public String getName（）：返回由此File表示的文件或者目录的名称。

public long length（）：返回由此File表示的文件的长度。

public class Demo {
    public static void main(String[] args) {
        File file = new File("d:/aaa/bbb.java");
        System.out.println("文件的绝对路径：" + file.getAbsoluteFile());
        System.out.println("文件的构造路径：" + file.getPath());
        System.out.println("文件的名称：" + file.getName());
        System.out.println("文件的长度：" + file.length()+"字节");

        File file2=new File("d:/aaa");
        System.out.println("目录的绝对路径：" + file2.getAbsoluteFile());
        System.out.println("目录的构造路径：" + file2.getPath());
        System.out.println("目录的名称：" + file2.getName());
        System.out.println("目录的长度：" + file2.length());
    }
}

文件的绝对路径：d:\aaa\bbb.java
文件的构造路径：d:\aaa\bbb.java
文件的名称：bbb.java
文件的长度：1345字节
目录的绝对路径：d:\aaa
目录的构造路径：d:\aaa
目录的名称：aaa
目录的长度：0

绝对路径和相对路径

绝对路径：从盘符开始的路径，是一个完整的路径。

相对路径：相对于项目目录的路径，这是一个便捷的路径，开发中常用。

public class FilePatn {
    public static void main(String[] args) {
        //D盘下的bbb.java文件
        File f1=new File("D:\\bbb.java");
        System.out.println(f1.getAbsoluteFile());
        //项目下的bbb.java文件
        File f2=new File("bbb.java");
        System.out.println(f2.getAbsoluteFile());
    }
}

D:\bbb.java
D:\javawrite\bbb.java

判断功能的方法：

public boolean exists()；此File表示的文件或者目录是否存在。

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

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

public class FilePatn {
    public static void main(String[] args) {
        File f =new File("d:\\aaa\\bbb.java");
        File f2 =new File("d:\\aaa");
        System.out.println("d:\\aaa\\bbb.java 是否存在"+f.exists());
        System.out.println("d:\\aaa 是否存在"+f2.exists());
        System.out.println("d:\\aaa 是文件？"+f.isFile());
        System.out.println("d:\\aaa 是目录？"+f.isDirectory());
    }
}

d:\aaa\bbb.java 是否存在true
d:\aaa 是否存在true
d:\aaa 是文件？true
d:\aaa 是目录？false

创建删除功能的方法;

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

public boolean delete():删除有此File表示的文件或者目录。

public boolean mkdir():创建有此File表示的目录。

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

public class FilePatn {
    public static void main(String[] args) throws IOException {
        //文件的创建
        File f =new File("aaa.java");
        System.out.println("aaa.java 是否存在"+f.exists());//false
        System.out.println("创建"+f.createNewFile());//true
        System.out.println("aaa.java 是否存在"+f.exists());//true
        System.out.println("aaa.java 目录？"+f.isDirectory());//false
        System.out.println("aaa.java 文件？"+f.isFile());//true
        System.out.println("aaa.java 绝对路径"+f.getAbsoluteFile());//D:\javawrite\aaa.java
        System.out.println("aaa.java 相对路径"+f.getPath());//aaa.java
        //目录的创建
        File f1=new File("newDirs");
        System.out.println("newDirs 是否存在"+f1.exists());//false
        System.out.println("创建"+f1.mkdir());//true
        System.out.println("newDir 是否存在"+f1.exists());//true
        System.out.println("newDir 目录？"+f1.isDirectory());//true
        System.out.println("newDir 文件？"+f1.isFile());//false
        System.out.println("newDir 绝对路径"+f.getAbsoluteFile());//D:\javawrite\aaa.java
        System.out.println("newDir 相对路径"+f.getPath());//newDir 相对路径aaa.java
        //创建多级目录
        File f2=new File("newDirb\\newDirc");
        System.out.println(f2.mkdir());//false
        File f3=new File("newDirb\\newDirc");
        System.out.println(f3.mkdirs());//true
        //文件的删除
        System.out.println(f.delete());//true
        //目录的删除
        System.out.println(f1.delete());//true
        System.out.println(f3.delete());//false
    }
}

elete方法，如果此File表示目录，则目录必须为空才能删除。

1.4 目录的遍历

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

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

public class FilePatn {
    public static void main(String[] args){
        File dir=new File("d:\\javawrite");
        //获取当前目录下的文件以及文件夹的名称
        String[] list = dir.list();
        for (String s : list) {
            System.out.println(s);
            /*
          .idea  hs_err_pid13284.log  javawrite.iml  newDi 
           newDir newDira newDirb  out  src
             */
        }
        //获取当前目录下的文件及文件对象，只要拿到了文件对象，那么就可以获取更多的信息
        File[] files=dir.listFiles();
        for (File file : files) {
            System.out.println(file);
            /*
            d:\javawrite\.idea   d:\javawrite\hs_err_pid13284.log   d:\javawrite\javawrite.iml
            d:\javawrite\newDi   d:\javawrite\newDir  d:\javawrite\newDira   d:\javawrite\newDirb
            d:\javawrite\out  d:\javawrite\src
             */
        }
    }
}

调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历。

2.递归

2.1 概述：

递归：指在当前的方法内调用自己的情况。

递归的分类：直接递归、间接递归

直接递归：方法自身调用自身

间接递归：A方法调用B方法，B方法调用C方法，C方法调用A方法。

注：

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

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

（3）构造方法，禁止递归。

public class DemoDiGui {
    //1.构造方法中，禁止递归
    public DemoDiGui() {
    }
    public static void main(String[] args) {
        b(1);
        //a();
    }
    /*
    2.在递归中虽然有条件限制，但是递归的次数也不能太多，不然会发生栈内存溢出
     */
    private static void b(int i) {
        System.out.println(i);
        //添加一个递归结束的条件，i==5000的时候结束
        if(i==5000){
            return;//结束方法
        }
        b(++i);
    }
    /*
    3.递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。Exception in thread "main"
       java.lang.StackOverflowError
     */
    private static void a(){
        System.out.println("a方法");
        a();
    }
}

2.2 递归累加求和

需求：计算1-n的和

分析：num的累和=num+(num-1) 的累和，所以把累和的操作定义成一个方法，递归调用。

public class DemoDiGui {
    public static void main(String[] args) {
        //计算1-num的和，使用递归完成
        int num=10;
        int numb = getnumb(num);
        System.out.println(numb);
    }

    private static int getnumb(int num) {
        if(num==1){//作为递归的限制条件，总会是1的
            return 1;
        }
        //num不为1时,方法返回 num +(num‐1)的累和.递归调用getSum方法
        return num=num+getnumb(num-1);
    }
}

代码执行图解：

2.3 递归求阶乘

n的阶乘：n!=n*(n-1)*(n-2)*(n-3)*.....*3*2*1

分析：n!=n*(n-1)!

public class DemoDiGui {
    public static void main(String[] args) {
        //计算n!的和，使用递归完成
        int n=4;
        int numb = getn(n);
        System.out.println(numb);
    }

    private static int getn(int n) {
        if(n==1){//作为递归的限制条件，总会是1的
            return 1;
        }
        //num不为1时,方法返回n*getn(n-1) 的阶乘.递归调用getn方法
        return n*getn(n-1);
    }
}

2.4 递归打印多级目录

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

public class DemoDiGui {
    public static void main(String[] args) {
        //创建File对象
        File dir=new File("D:\\javawrite");
        //调用自定义的打印方法
        printDir(dir);
    }

    private static void printDir(File dir) {
        //获取子文件和目录
        File[] files=dir.listFiles();
        /*
        1.循环打印
            判断要是文件，打印绝对路径
                要是目录，打印相对路径
         */
        for (File file : files) {
            if(file.isFile()){
                System.out.println("文件名"+file.getAbsoluteFile());
            }else if(file.isDirectory()){
                System.out.println("目录"+file.getPath());
                //继续遍历调用printDir方法，形成递归
                printDir(file);
            }
        }
    }
}

2.5 文件搜索案例

需求:搜索D：\\javawrite 目录中的 .java文件

分析：目录搜索，无法判断多少级目录，所以使用递归，遍历所有目录，遍历目录时，获取的子文件，通过文件名称，判断是否符合条件。

public class DemoDiGui {
    public static void main(String[] args) {
        //创建File对象
        File dir=new File("D:\\javawrite");
        //调用自定义的打印方法
        printDir(dir);
    }

    private static void printDir(File dir) {
        //获取子文件和目录
        File[] files=dir.listFiles();
        /*
        1.循环打印
            判断要是文件 .java，打印
         */
        for (File file : files) {
            if(file.isFile()){
                //是文件，就判断文件名并输出绝对路径
                if(file.getName().endsWith(".java")){
                    System.out.println("文件名"+file.getAbsoluteFile());
                }
            }else{
                //不是文件，就是目录。继续遍历调用printDir方法，形成递归
                printDir(file);
            }
        }
    }
}

2.6 文件过滤器优化

java.io.FileFilter是一个接口，是file的过滤器。该接口的对象可以传递给File类的listFiles(FileFilter)作为参数，接口中只有一个方法。

boolean accept(File pathname) ：测试pathname是否应该包含在当前File目录中，符合则返回true。

分析：1. 接口作为参数，需要传递子类对象，重写其中方法。我们选择匿名内部类方式，比较简单。

2. accept 方法，参数为File，表示当前File下所有的子文件和子目录。保留住则返回true，过滤掉则返回false。保留规则：

（1）要么是.java文件。

（2）要么是目录，用于继续遍历。

3. 通过过滤器的作用， listFiles(FileFilter) 返回的数组元素中，子文件对象都是符合条件的，可以直接打印。

public class DemoDiGui {
    public static void main(String[] args) {
        //创建File对象
        File dir=new File("D:\\javawrite");
        //调用自定义的打印方法
        printDir(dir);
    }

    private static void printDir(File dir) {
        //匿名内部类方式，创建过滤器子类对象
        File[] files=dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.getName().endsWith(".java")||pathname.isDirectory();
            }
        });
        //循环打印
        for (File file : files) {
            if(file.isFile()){
                    System.out.println("文件名"+file.getAbsoluteFile());
            } else{
                //不是文件，就是目录。继续遍历调用printDir方法，形成递归
                printDir(file);
            }
        }
    }
}

2.7 lambda 优化

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

public class DemoDiGui {
    public static void main(String[] args) {
        //创建File对象
        File dir=new File("D:\\javawrite");
        //调用自定义的打印方法
        printDir(dir);
    }

    private static void printDir(File dir) {
        //匿名内部类方式，创建过滤器子类对象
        //对比上个程序 f为FileFilter接口中Accept方法中的参数，自定义为的f   ,不要迷惑
        File[] files=dir.listFiles(f->f.getName().endsWith(".java")||f.isDirectory());
        //循环打印
        for (File file : files) {
            if(file.isFile()){
                    System.out.println("文件名"+file.getAbsoluteFile());
            } else{
                //不是文件，就是目录。继续遍历调用printDir方法，形成递归
                printDir(file);
            }
        }
    }
}

王胖子总叫我减肥

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java File类、递归的详细介绍

1.File类1.1 概述： java.io.File类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等。1.2 构造方法 public File(String pathname):通过给定的路径名字符串转换成抽象路径名来创建新的File实例。 public File（String parent，String child）：从父路径名...
复制链接

扫一扫