java入门（File类、递归）

最新推荐文章于 2022-03-03 06:00:00 发布

Li_CSDN_Li

最新推荐文章于 2022-03-03 06:00:00 发布

阅读量125

点赞数

分类专栏： java入门

本文链接：https://blog.csdn.net/Li_CSDN_Li/article/details/107449241

版权

java入门专栏收录该内容

22 篇文章 0 订阅

订阅专栏

File类、递归

File类

1. File类的对象创建

File类的对象构建：就是用来描述我们计算机中的文件或者目录

构造方法：

- public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
- public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。
- public File(File parent, String child) ：从父抽象路径名和子路径名字符串创建新的 File实例。

注意：

即使硬盘中实际不存在该文件，也能够创建对象
文件的路径是有分割符的，父子目录之间需要使用 \\进行分割，当然也可以使用 /

/*
路径分割符:
Windows: \\
Unix/Linux/MacOS ： /

 */
public class Demo01 {
    public static void main(String[] args) {
        //- public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
        File f1 = new File("D:\\abc");
        System.out.println("f1 = " + f1);

        File f2 = new File("D:/abc");
        System.out.println("f2 = " + f2);


        //- public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。
        String parent = "D:/abc";
        String child = "流浪地球.avi";

        File f3 = new File(parent, child);
        System.out.println("f3 = " + f3);


        //- public File(File parent, String child) ：从父抽象路径名和子路径名字符串创建新的 File实例。
        File pf = new File(parent);
        File f4 = new File(pf, child);
        System.out.println("f4 = " + f4);


        //注意：即使计算机本地中没有此文件也可以使用构造方法进行构建对象
        File f5 = new File("X:/abac");
        System.out.println("f5 = " + f5);

    }
}

2.File类的常用方法：获取类方法

- public String getAbsolutePath() ：
- 返回此File的绝对路径名字符串。【从盘符开始的路径】
- public String getPath() ：
- 将此File转换为路径名字符串。【获取构造路径】
- public String getName()  ：
- 返回由此File表示的文件或目录的名称。
- public long length()  ：
- 返回由此File表示的文件的长度。【文件的大小，单位是字节】
【如果是实际存在的文件返回才有意义】
如果是文件夹或者是不存在的文件，会返回0或其他数据，没有实际作用

public class Demo01 {
    public static void main(String[] args) {
        File f1 = new File("D:/abc/流浪地球.avi");
        //- public String getAbsolutePath() ：返回此File的绝对路径名字符串。【从盘符开始的路径】
        String absolutePath = f1.getAbsolutePath();
        System.out.println("absolutePath = " + absolutePath);

        //- public String getPath() ：将此File转换为路径名字符串。【获取构造路径】
        File f2 = new File("file01.txt");
        String path = f2.getPath();
        System.out.println("path = " + path);

        String path1 = f1.getPath();
        System.out.println("path1 = " + path1);


        //- public String getName()  ：返回由此File表示的文件或目录的名称。
        String name = f1.getName();
        System.out.println("name = " + name);

        //- public long length()  ：返回由此File表示的文件的长度。【文件的大小，单位是字节】
        File f3 = new File("D:/abc/数学之美.PDF");
        long len = f3.length();
        System.out.println("len = " + len);


        //【如果是实际存在的文件返回才有意义】
        //如果是文件夹或者是不存在的文件，会返回0或其他数据，没有实际作用
        File f4 = new File("D:/abc");
        System.out.println("f4.length() = " + f4.length());

        File f5 = new File("X:/abc.txt");
        System.out.println("f5.length() = " + f5.length());
        

    }
}

3.绝对路径和相对路径

绝对路径：从盘符开始的路径
相对路径：相对于项目的根路径【适合用来描述本项目中的文件】
相对路径比绝对路径更灵活，会随着工程根路径的变化而变化

import java.io.File;
/*
相对的是当前工程的目录
 */
public class Demo01 {
    public static void main(String[] args) {
        //相对路径描述工程中的文件
        File f1 = new File("file01.txt");//相对路径定义的文件
        System.out.println("f1 = " + f1);

        File f3 = new File("dir1/file02.txt");
        System.out.println("f3.getAbsolutePath() = " + f3.getAbsolutePath());

        //获取绝对路径
        String absolutePath = f1.getAbsolutePath();
        System.out.println("absolutePath = " + absolutePath);

        //绝对路径
        File f2 = new File("D:\\CodeInClass\\JY_JavaEE86Code\\day11\\file01.txt");
        System.out.println("f2 = " + f2);
        
    }
}

4.File类中的方法：判断类方法

- public boolean exists() ：
- 此File表示的文件或目录是否实际存在。
- public boolean isDirectory() ：
- 此File表示的是否为目录。
-【不存在的文件，或目录，返回都是false】
- public boolean isFile() ：
- 此File表示的是否为文件。
-【不存在的文件，或目录，返回都是false】

文件的分类：
1）文件夹，目录
2）文件

public class Demo01 {
    public static void main(String[] args) {
        //- boolean exists() ：此File表示的文件或目录是否实际存在。
        File f1 = new File("file01.txt");
        boolean exists = f1.exists();
        System.out.println("exists = " + exists);

        File f2 = new File("file03.txt");
        System.out.println("f2.exists() = " + f2.exists());

        //- boolean isDirectory() ：此File表示的是否为目录。【不存在的文件，或目录，返回都是false】
        File f3 = new File("dir1");
        System.out.println("f3.isDirectory() = " + f3.isDirectory());//true 文件夹/目录
        File f4 = new File("dir2");
        System.out.println("f4.isDirectory() = " + f4.isDirectory());//false 不存在

        System.out.println("f1.isDirectory() = " + f1.isDirectory());//false 是文件

        //- boolean isFile() ：此File表示的是否为文件。【不存在的文件，或目录，返回都是false】
        System.out.println("f1.isFile() = " + f1.isFile()); //true
        File f5 = new File("file04.txt");
        System.out.println("f5.isFile() = " + f5.isFile());//false //不存在

        System.out.println("f3.isFile() = " + f3.isFile());//false 是目录

    }
}

5.文件的创建和删除

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

如果创建文件时，无法找到实际的路径，报错
public boolean delete() ：删除由此File表示的文件或目录。

永久删除，如果是文件夹，那么要求文件夹内容为空，才能删除
public boolean mkdir() ：创建由此File表示的目录。

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

可以创建多级目录，如果父目录不存在，会自动创建

public class Demo01 {
    public static void main(String[] args) throws IOException {
        //- public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
        File f1 = new File("file02.txt");
        System.out.println("f1.createNewFile() = " + f1.createNewFile());

        //如果创建文件时，无法找到实际的路径，报错
        //File f2 = new File("X:/file01.txt");
        //System.out.println("f2.createNewFile() = " + f2.createNewFile());  //报错


        //- public boolean mkdir() ：创建由此File表示的目录。
        File f4 = new File("dir2");
        System.out.println("f4.mkdir() = " + f4.mkdir());//true
        //  只能创建单层目录
        File f5 = new File("dir3/abc/def");
        System.out.println("f5.mkdir() = " + f5.mkdir());//false


        //- public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。
        //  可以创建多级目录，如果父目录不存在，会自动创建
        System.out.println("f5.mkdirs() = " + f5.mkdirs());//true


        //- public boolean delete() ：删除由此File表示的文件或目录。
        //永久删除，如果是文件夹，那么要求文件夹内容为空，才能删除
        //文件删除
        System.out.println("f1.delete() = " + f1.delete());//true

        File f3 = new File("file03.txt");
        System.out.println("f3.delete() = " + f3.delete());//false
        //文件夹的删除
        File f6 = new File("dir2");
        System.out.println("f6.delete() = " + f6.delete());

        File f7 = new File("dir3");
        System.out.println("f7.delete() = " + f7.delete()); //false 文件夹不为空

    }
}

6.目录的遍历

- public String[] list() ：
- 返回一个String数组，表示该File目录中的所有子文件或目录。
-【不包含孙文件，只能获取当前目录的子文件】
- public File[] listFiles() ：
- 返回一个File数组，表示该File目录中的所有的子文件或目录。
-【不包含孙文件，只能获取当前目录的子文件】

一定是有效的文件才能返回结果,
如果是一个无效的目录【文件，或者不存在的目录】，返回null
如果是一个有效的目录但没有子文件，返回数组，但是里面没有元素

public class Demo01 {
    public static void main(String[] args) {
        //- public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。【不包含孙文件，只能获取当前目录的子文件】
        File f1 = new File("D:/abc");
        String[] fileNames = f1.list();
        for (String fileName : fileNames) {
            System.out.println("fileName = " + fileName);
        }

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

        //- public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。【不包含孙文件，只能获取当前目录的子文件】
        File[] files = f1.listFiles();
        for (File file : files) {
            System.out.println("file = " + file);
        }

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

        //如果是一个无效的目录【文件，或者不存在的目录】，返回null
        File f2 = new File("Z:/abc");
        System.out.println("f2.list() = " + f2.list());
        System.out.println("f2.listFiles() = " + f2.listFiles());


        //如果是一个有效的目录但没有子文件，返回数组，但是里面没有元素
        File f3 = new File("dir4");
        System.out.println("f3.list() = " + f3.list().length);
        System.out.println("f3.listFiles() = " + f3.listFiles().length);
        
    }
}

7.文件过滤

public class Demo {
    public static void main(String[] args) {
        File f = new File("G:\\abc");
        
//        定义的过滤器
        FileFilter filter = new FileFilter() {
            @Override
            public boolean accept(File pathname) {
//                return false;
                return pathname.getName().endsWith(".txt");
            }
        };
        
//        使用过滤器
        File[] files = f.listFiles(filter);
        for (File file : files) {
            System.out.println("file = " + file);
        }
    }
}

文件过滤（打印出以.txt结尾的文件）
在这里插入图片描述

递归

1.递归的概念及运行原理分析

【递归概念】方法内部调用自身

为什么要调用自己？
方法体现了一个功能，如果方法中的逻辑需要自身方法的功能，可以自己调用自己

注意：递归调用，一定要保证有结束条件，如果没有结束，无限递归会导致栈内存溢出，程序崩溃
在这里插入图片描述

2.求阶乘案例

/*
n的阶乘：n! = n * (n-1) *...* 3 * 2 * 1
 */
public class Demo01 {
    public static void main(String[] args) {
        long jieCheng = jieCheng(10);
        System.out.println("jieCheng = " + jieCheng);

    }


    public static long jieCheng(int num) {
        if (num == 1) {
            return 1;
        }

        return num * jieCheng(num - 1);
    }
}

3.递归实现文件搜索和文件删除案例

需求：搜索D:\abc 路径下所有的 .java文件

步骤：
1）定义一个方法，用来打印传入目录下面的所有.java文件
2）方法内部实现：
    1：获取传入的目录的所有子文件，遍历子文件
    2：文件如果是文件类型，直接判断后缀是否为.java，如果是打印
    3：文件如果是目录类型，
        调用方法自己

/*
需求：搜索D:\abc 路径下所有的 .java文件

步骤：
1）定义一个方法，用来打印传入目录下面的所有.java文件
2）方法内部实现：
    1：获取传入的目录的所有子文件，遍历子文件
    2：文件如果是文件类型，直接判断后缀是否为.java，如果是打印
    3：文件如果是目录类型，
        调用方法自己
 */
public class Demo01 {
    public static void main(String[] args) {
        //printJavaFile(new File("D:/abc"));

        deleteFile(new File("D:\\abc"));

    }

    public static void printJavaFile(File dir) {
        File[] files = dir.listFiles();
        if (files != null) {
            //1：获取传入的目录的所有子文件，遍历子文件
            for (File file : files) {
                if (file.isFile()) {
                    //2：文件如果是文件类型，直接判断后缀是否为.java，如果是打印
                    // String toLowerCase() : 字符串中的字母统统变为小写
                    if (file.getName().toLowerCase().endsWith(".java")) {
                        System.out.println(file);
                    }
                } else {
                    //3：文件如果是目录类型，
                    //    调用方法自己
                    printJavaFile(file); //【递归调用】
                }

            }

        }

    }


    //删除文件夹，删除文件
    public static void deleteFile(File file) {
        if (file.isFile()) {
            //删除文件
            file.delete();
        } else if (file.isDirectory()) {
            //删除文件夹
            File[] files = file.listFiles();
            //先把子文件删除
            for (File child : files) {
                //有可能是文件夹，文件
                deleteFile(child);
            }
            //子文件已经删除完了，删除本文件夹
            file.delete();
        }
    }
}

4.递归思想实现不死神兔和猴子吃桃

不死神兔

public class Demo {
    public static void main(String[] args) {
        int rabbit = rabbit(6);
        System.out.println("rabbit = " + rabbit);
    }

    /** 不死神兔：从第三个月起，每个月的兔子数是前两个月兔子数之和
     * @param i 月
     * @return
     */
    public static int rabbit(int i) {
        if (i == 1) {
            return 1;
        }else if (i == 2) {
            return 1;
        }
        return rabbit(i-1) + rabbit(i-2);
    }
}

猴子吃桃

/*
描述:猴子吃桃子问题，猴子第一天摘下若干个桃子，
当即吃了快一半，还不过瘾，又多吃了一个。
第二天又将仅剩下的桃子吃掉了一半，又多吃了一个。
以后每天都吃了前一天剩下的一半多一个。
到第十天，只剩下一个桃子。试求第一天共摘了多少桃子？
     9         10
     n         n/2 - 1
                1
    2(m+1)      m
 */
public class Demo {
    public static void main(String[] args) {
        int sumPeach = sumPeach(1);
        System.out.println("sumPeach = " + sumPeach);
    }

    public static int sumPeach(int day) {
//        判断如果是第十天就返回1
        if (day == 10) {
            return 1;
        }
//        递归计算前一天的数量
        return 2*sumPeach(day + 1) + 2;
    }
}
一天剩下的一半多一个。
到第十天，只剩下一个桃子。试求第一天共摘了多少桃子？
     9         10
     n         n/2 - 1
                1
    2(m+1)      m
 */
public class Demo {
    public static void main(String[] args) {
        int sumPeach = sumPeach(1);
        System.out.println("sumPeach = " + sumPeach);
    }

    public static int sumPeach(int day) {
//        判断如果是第十天就返回1
        if (day == 10) {
            return 1;
        }
//        递归计算前一天的数量
        return 2*sumPeach(day + 1) + 2;
    }
}

Li_CSDN_Li

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java入门（File类、递归）

File类、递归File类1. File类的对象创建File类的对象构建：就是用来描述我们计算机中的文件或者目录构造方法：- public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。- public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。- public File(File parent, String child) ：从父抽象路径名
复制链接

扫一扫

专栏目录