2022/07/08 day01：File类、递归

最新推荐文章于 2022-10-24 21:39:52 发布
最新推荐文章于 2022-10-24 21:39:52 发布
阅读量115 收藏
点赞数
分类专栏： 03 java语言高级（二） 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w2079930908/article/details/125686405
版权

文章目录

1. File类

1.1 file类的基本介绍

java.io.File类
文件和目录路径名的抽象表示形式：java把电脑中的文件和文件夹（目录）封装成一个File类，我们使用File类对文件和文件夹进行操作。

我们可以使用file类的方法：

  • 创建一个文件/文件夹

  • 删除文件/文件夹

  • 获取文件/文件夹

  • 判断文件/文件夹是否存在

  • 对文件夹进行遍历（看其中有哪些内容）

  • 获取文件的大小

File类是一个与系统无关的类，任何的操作系统都可以使用这个类中的方法

重点记住这三个单词：
file：文件
directory：文件夹（目录）
path：路径

1.2 静态成员变量

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

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

注意：

  1. String与char只是返回值类型不一样，作用是一样的。
  2. 操作路径：路径不能写死了。
    写死了就是要出现歧义了，因为Windows与Linux不一样，但File.separator是一样的。
    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);// ;  pathSeparator指路径分隔符
       // 补充：Windows是;分号，但是Linux是：冒号

       String separator = File.separator;
       System.out.println(separator);//  \  separator指文件名称分隔符
       // 补充：Windows是反斜杠\，Linux是正斜杠/.
   }
}

1.3 绝对路径和相对路径

路径：
1. 绝对路径：是一个完整的路径
以盘符(C:,D:) 开始的路径
C:\Users\Admin\Desktop\123.txt
E:\Admin
2. 相对路径：简化的路径
相对指的是：相对于当前项目的根目录(C:\Users\Admin\Desktop)
如果使用当前项目的根目录，路径可以简化书写
C:\Users\Admin\Desktop\123.txt --> 123.txt(可以省略项目的根目录)

注意：

  1. 路径不区分大小写；
  2. 路径中的文件名称的分隔符，Windows使用反斜杠\。反斜杠又是转义字符，两个反斜杠代表一个普通含义的反斜杠。

1.4 File类的构造方法

构造方法1

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

private static void show1() {
        File f1 =new File("C:\\Users\\Admin\\Desktop\\a.txt");
        System.out.println(f1);//重写了Object类中的toString方法 C:\Users\Admin\Desktop\a.txt   假-文件结尾-绝对路径

        File f2 =new File("C:\\Users\\Admin\\Desktop");
        System.out.println(f2);//C:\Users\Admin\Desktop 真-文件名结尾-绝对路径

        File f3 = new File("b.txt");
        System.out.println(f3);//b.txt 假-文件结尾-相对路径
    }

构造方法2

File(String parent, String child) 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
参数：把路径分成了两部分：
-String parent：父路径
-String child：子路径

好处：
-父路径和子路径，可以单独书写，使用起来非常灵活；父路径和子路径都可以变化。


        show2("C:\\","a.txt");C:\a.txt
        show2("D:\\","a.txt");//D:\a.txt  是不是很灵活啊

private static void show2(String parent, String child) {
        File file = new File(parent,child);
        System.out.println(file);
    }

构造方法3

File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
参数：把路径分成了两部分：
-File parent：父路径
-String child：子路径

好处：

  • 父路径和子路径，可以单独书写，使用起来非常灵活；父路径和子路径都可以变化。
  • 父路径是File类型，可以使用File内的方法对路径进行一些操作，再使用路径创建对象
    private static void show3() {
        File parent = new File("c:\\"); //这是第一个构造方法
        File file = new File(parent,"hello,java");//这里可以点
        System.out.println(file);//c:\hello,java
    }

1.5 FIle类常用方法

1.5.1 获取功能方法

File类获取功能的方法

  • public String getAbsolutePath() ：返回此File的绝对路径名字符串。
  • public String getPath() ：将此File转换为路径名字符串。
  • public String getName() ：返回由此File表示的文件或目录的名称。
  • public long length() ：返回由此File表示的文件的大小。
获取绝对路径

public String getAbsolutePath() ：返回此File的绝对路径名字符串。
获取构造方法中传递的路径，无论这个路径是绝对的还是相对的，返回的都是绝对路径。

private static void show1() {
        File f1 = new File("C:\\Users\\Admin\\Desktop\\a.txt");
        System.out.println(f1);//C:\Users\Admin\Desktop\a.txt
        String absolutePath1 = f1.getAbsolutePath();
        System.out.println(absolutePath1);//C:\Users\Admin\Desktop\a.txt

        File f2 = new File("b.txt");
        String absolutePath2 = f2.getAbsolutePath();
        System.out.println(absolutePath2);//E:\learn java\IDEA\day01_API\b.txt
        //当前项目所在的路径就是根路径
    }
获取路径

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

获取构造方法中传递的路径：路径是什么样，获取的就是什么样。

toString方法调用的其实就是getPath方法
源码：
public String toString() {
return getPath();
}

private static void show2() {
        File f1 = new File("C:\\Users\\Admin\\Desktop\\a.txt");
        File f2 = new File("b.txt");
        String path1 = f1.getPath();
        System.out.println(path1);//C:\Users\Admin\Desktop\a.txt
        String path2 = f2.getPath();
        System.out.println(path2);//b.txt

        System.out.println(f1.toString()); //其实就是getPath方法
        System.out.println(f2.toString());//b.txt
    }
获取结尾名称

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

获取就是构造方法传递路径的结尾部分（要么是文件，要么是文件夹）

private static void show3() {
       File f1 = new File("C:\\Users\\Admin\\Desktop\\a.txt");
       String name1 = f1.getName();
       System.out.println(name1);//a.txt
       File f2 = new File("C:\\Users\\Admin\\Desktop");
       String name2 = f2.getName();
       System.out.println(name2);//Desktop

   }
获取文件大小

public long length() ：返回由此File表示的文件的大小。
获取的是构造方法指向的文件的大小，以字节为单位。

注意：
文件夹是没有大小概念的，不能获取文件夹的大小 （难怪这个文件夹的字节数不对）
如果构造方法中给出的路径不存在，那么length返回0

    private static void show4() {
        File f1 = new File("C:\\Users\\Admin\\Desktop\\a.txt");
        long length = f1.length();
        System.out.println(length); //0 虚构I的

        File f2 = new File("C:\\Users\\Admin\\Desktop");
        long length2 = f2.length();
        System.out.println(length2);//4096 但还是有，why？

        File f3 = new File("C:\\Users\\Admin\\Desktop\\b.txt");
        long length3 = f3.length();
        System.out.println(length3);//3
    }

1.5.2 判断功能方法

  • public boolean exists() ：此File表示的文件或目录是否实际存在。
  • public boolean isDirectory() ：此File表示的是否为目录。
  • public boolean isFile() ：此File表示的是否为文件。
判断路径是否有效

public boolean exists() ：此File表示的文件或目录是否实际存在。
用来判断构造方法中的路径是否存在。
-存在：true
-不存在：false

private static void show1() {
        File f1 = new File("C:\\Users\\Admin\\Desktop\\a.txt");
        boolean exists = f1.exists();
        System.out.println(exists);//false

        File f2 = new File("day01_API.iml");
        boolean exists2 = f2.exists();
        System.out.println(exists2);//true
    }
判断有效路径尾巴

public boolean isDirectory() ：此File表示的是否为目录。
在路径有效的基础上用于判断构造方法中给定的路径是否以文件夹结尾。
-是：true
-不是：false

public boolean isFile() ：此File表示的是否为文件。
在路径有效的基础上用于判断构造方法中给定的路径是否以文件结尾。
-是：true
-不是：false

注意：
-电脑的硬盘当中只有文件或文件夹，所以同一物体只能有一个属性（互斥）
-这两个方法的有效前提是路径是有效的，否则都返回false。

private static void show2() {
        File f1 = new File("C:\\Users\\Admin\\Desktop\\a.txt");
        //路径无效就没有必要获取
        if(f1.exists()){
            System.out.println(f1.isDirectory());
            System.out.println(f1.isFile());
        }


        File f2 = new File("C:\\Users\\Admin\\Desktop\\b.txt");
        if(f2.exists()){
            System.out.println(f2.isDirectory());//false
            System.out.println(f2.isFile());//true
        }
    }

1.5.3 创建与删除功能方法

File类创建删除功能的方法

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

public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
创建文件的路径和名称在构造方法中给出（构造方法的参数）
返回值

  • true：文件不存在，创建文件，返回true
  • false：文件存在，不会创建，返回false

注意：
1. 此方法只能创建文件，不能创建文件夹
2. 创建文件的路径必须存在，否则会抛出异常

public boolean createNewFile() throws IOException
createNewFile声明抛出IOException，我们调用这个方法，就必须处理这个异常
-要么throws继续声明，要么try…catch自己处理
-路径不存在时，会抛出IOException。

 private static void show1() throws IOException {
        File f1 = new File("C:\\Users\\Admin\\Desktop\\a.txt");
        boolean newFile = f1.createNewFile();
        System.out.println("newFile：" + newFile);//true

        File f2 = new File("day01_API.txt");
        boolean newFile1 = f2.createNewFile();
        System.out.println("newFile1：" + newFile1);
    }
创建文件夹

public boolean mkdir() ：创建由此File表示的目录。
只能创建单级空文件夹
public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。
既可以创建单级空文件夹，也可以创建多级文件夹

创建文件夹的路径和名称在构造方法中给出（构造方法的参数）
返回值

  • true：文件夹不存在，创建文件夹，返回true
  • false：文件夹存在，不会创建，返回false 构造方法中给出的路径无效也返回false

注意：
此方法只能创建文件夹，不能创建文件

    private static void show2() {
        File f1 = new File("C:\\Users\\Admin\\Desktop\\新文件夹");
        boolean mkdir = f1.mkdir();
        System.out.println("mkdir：" + mkdir);

        File f2 = new File("C:\\Users\\Admin\\Desktop\\新文件夹\\1\\2\\3");
        boolean mkdirs = f2.mkdirs();
        System.out.println(mkdirs);

        File f3 = new File("新文件夹\\1\\2");
        System.out.println(f3.mkdirs());
        System.out.println(f3.getAbsolutePath());
    }
删除文件/文件夹

public boolean delete() ：删除由此File表示的文件或目录。
此方法可以删除构造方法路径中给出的文件/文件夹
返回值：布尔值

  • true：文件/文件夹删除成功 ，返回true
  • false：文件夹中有内容，不会删除返回false；构造方法中的路径无效，也返回false

注意：delete方法是直接在硬盘删除文件夹/文件，不经过回收站，删除需谨慎

    private static void show3() {
        File f1 = new File("新文件夹\\1\\2");
        boolean delete = f1.delete();
        System.out.println("delete：" + delete);

        File f2 = new File("day01_API.txt");
        boolean delete1 = f2.delete();
        System.out.println("delete1：" + delete1);
    }

1.4 遍历文件/目录功能

File类遍历（文件夹）目录功能：

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

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

遍历文件夹下所有名称

public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
遍历构造方法中给出的目录，会获取目录中所有文件/文件夹的名称，把获取到的多个名称存储到一个String类型的数组当中。（还可以获取隐藏的文件）
【这个只会把名称打印出来】

 private static void show1() {
        File f1 = new File("E:\\learn java\\IDEA\\day01_API");
        String[] list = f1.list();
        for (String fileName : list) {
            System.out.println(fileName);
        }

        File f2 = new File("E:\\learn java\\IDEA\\day01_API\\day01_API.txt");
        String[] list1 = f2.list();
        for (String fileName : list1) {
            System.out.println(fileName);//空指针异常
        }
    }
遍历文件夹下所有路径

public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
遍历构造方法中给出的目录，会获取目录中所有的文件/文件夹，并把其封装为File对象，多个File对象存储到File数组中
【这个会把路径打印出来】

private static void show2() {
        File f1 = new File("E:\\learn java\\IDEA\\day01_API");
        File[] files = f1.listFiles();
        for (File fileName : files) {
            System.out.println(fileName);
        }

    }

2. 递归

2.1 递归概述

递归概念

递归：方法自己调用自己。

递归分类

递归的分类:

  • 递归分为两种，直接递归和间接递归。
  • 直接递归称为方法自身调用自己。
  • 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。

注意事项

注意事项：

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

溢出原理
在这里插入图片描述

  • 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
private static void b(int i) {
        System.out.println(i);
        if(i == 2000){
            return;//结束方法
        }
        b(++i);
    }
  • 构造方法,禁止递归
/*
  构造方法,禁止递归
  编译报错：构造方法是创建对象使用的，一直递归会导致内存中有无数多个对象（地址），直接编译报错
   */
  public Demo01Recurison() {
      Demo01Recurison();
  }

使用前提

递归的使用前提：
当调用方法的时候，方法的主体不变，每次调用方法的参数不同，可以使用递归

2.2 递归累加求和

练习：使用递归计算1 ~ n的和。
定义一个方法，计算1~n的和
1+2+3+…n
n + (n-1)+(n-2)+(n-3)…+1

已知：
最大值：n
最小值：1

使用递归必须明确：

  1. 递归的结束条件：获取到1时，结束
  2. 递归的目的：获取下一个被加的数字（n-1)

递归原理
在这里插入图片描述

public class Demo02Recurison {
    public static void main(String[] args) {

        int s = sum(3);
        System.out.println(s);
    }

    public static int sum(int n){
        if(n == 1){
            return 1;
        }
        return n + sum(n-1);
    }
}

2.3 递归计算阶乘

练习：阶乘：所有小于及等于该数的正整数的积.
n的阶乘：n! = n * (n-1) … 3 * 2 * 1
5的阶乘：5！=5*(5-1)(5-2)…(5-4)

定义方法，使用递归计算阶乘
5的阶乘：5！=5*(5-1)(5-2)…(5-4)=54321

递归结束条件：获取到1时结束
递归的目的： 获取下一个被乘的数字（n-1)

方法的参数发生变化

public class Demo03Recurison {
    public static void main(String[] args) {

        long jc = jc(5);
        System.out.println(jc);//120
    }

    public static int jc(int n){
        //获取到1时结束
        if(n == 1){
            return 1;
        }
        //获取下一个被乘的数字（n-1)
        return n * jc(n-1);
    }
}

2.4 递归打印多级目录

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

在这里插入图片描述

public class Demo04 {
   public static void main(String[] args) {
       File f1 = new File("C:\\abc");
      getFile(f1);
   }
           /*
       定义一本方法，参数传递File类型的目录
       方法中对目录进行遍历
        */

   public static void getFile(File dir){
       System.out.println(dir);//打印被遍历的目录的名称
       File[] files = dir.listFiles();
       for (File f : files) {
           //对遍历得到的File对象进行判断，判断是否是文件夹
           if(f.isDirectory()){
               //f是一个文件夹，则继续遍历这个文件夹
               //我们发现getFile方法就是传递文件夹，遍历文件夹的方法
               //所以直接调用getFile方法即可，递归（自己调用自己）
               getFile(f);
           }else{
               System.out.println(f);
           }
       }
   }
}

3. 综合案例

3.1 文件搜索

练习：
递归打印多级目录之文件搜索
分析：
多级目录的打印，就是当目录的嵌套。遍历之前，无从知道到底有多少级目录，所以我们还是要使用递归实现。
需求：只要XXX.java结尾的文件。

  public static void getFile(File dir){
        //System.out.println(dir);//打印被遍历的目录的名称
        File[] files = dir.listFiles();
        for (File f : files) {
            //对遍历得到的File对象进行判断，判断是否是文件夹
            if(f.isDirectory()){
                //f是一个文件夹，则继续遍历这个文件夹
                //我们发现getFile方法就是传递文件夹，遍历文件夹的方法
                //所以直接调用getFile方法即可，递归（自己调用自己）
                getFile(f);
            }else{
               /* //c:\\abc\\abc.java
                //只要XXX.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);
                }
            }
        }
    }
}

3.2 FileFilter过滤器的原理和使用

在这里插入图片描述

需求：
遍历c:\abc文件夹，及abc文件夹的子文件夹
只要.java结尾的文件
C:\abc
C:\abc\a
C:\abc\a\a.jpg
C:\abc\a\a.txt
C:\abc\abc.java
C:\abc\abc.txt
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，在方法中自己定义过滤的规则


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");
    }
}


public class Demo01Filter {
    public static void main(String[] args) {
        File f1 = new File("C:\\abc");
        getFile(f1);
    }
            /*
        定义一本方法，参数传递File类型的目录
        方法中对目录进行遍历
         */

    public static void getFile(File dir){
        File[] files = dir.listFiles(new FileFilterImpl());//传递过滤器对象
        for (File f : files) {
            //对遍历得到的File对象进行判断，判断是否是文件夹
            if(f.isDirectory()){
                //f是一个文件夹，则继续遍历这个文件夹
                //我们发现getFile方法就是传递文件夹，遍历文件夹的方法
                //所以直接调用getFile方法即可，递归（自己调用自己）
                getFile(f);
            }else{
                System.out.println(f);
            }
        }
    }
    }

3.3 Lambda优化

import java.io.File;

public class Demo02Filter {
    public static void main(String[] args) {
        File f1 = new File("C:\\abc");
        getFile(f1);
    }
            /*
        定义一本方法，参数传递File类型的目录
        方法中对目录进行遍历
         */

    public static void getFile(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(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对象进行判断，判断是否是文件夹
            if(f.isDirectory()){
                //f是一个文件夹，则继续遍历这个文件夹
                //我们发现getFile方法就是传递文件夹，遍历文件夹的方法
                //所以直接调用getFile方法即可，递归（自己调用自己）
                getFile(f);
            }else{
                System.out.println(f);
            }
        }
    }
    }

                                                                                 ——此文档为学习笔记！
上水若善
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[Java进阶] 递归遍历file文件夹并统计文件类型
花与树
05-26 742
递归遍历文件夹,统计文件后缀个数
java 循环创建文件_java File基本操作，以及递归遍历文件夹
weixin_30983353的博客
02-12 1487
java 的文件操作，相对来说是比较重要的，无论是编写CS还是BS程序，都避免不了要与文件打交道，例如读写配置文件等。虽然现在很多框架都直接帮你做好了这一步！java.io.File 底层是调用与c语言接的接口，所以我们暂时不需要知道底层是怎么实现的，再说了，也看不见，最多就是看见一个接口而已。我们只需要知道java.io.File提供给我们对文件的一些操作就行了。1.文件的创建：java的文件创...
java基础-递归操作文件夹
qq_41044340的博客
06-11 206
java基础-递归操作文件夹前言递归打印结果结语 前言 今天看视频，学了一个递归操作，发现递归对文件操作特备方便，故自己码了一遍代码，做此记录。 递归 大家都知道，递归就是自己调用自己，有一个递归头和一个体，如果没有头，程序将无法结束循环，从而导致死循环。 话不多说，直接上代码。 package test; import java.io.File; public class Test { p...
java类file实现文件递归查找指定文件名后缀，过滤器
weixin_40228600的博客
10-24 1015
java类file实现文件递归查找指定文件名后缀，过滤器
Java 快速创建及递归删除文件
Amewin的博客
04-13 1763
Java File创建及递归删除文件 开发工具与关键技术：java、 elipse2019、jdk1.8 作者：Amewin 撰写时间：2019年4月13日 File 类的说明： 在 Java 中，File 类是java.io包中唯一代表磁盘文件本身的对象。File 类定义了一些与平台无关的方法来操作文件，File类主要用来获取或处理与磁盘文件相关的信息，像文件名、 文件路径、访问权限和修改日期...
day08【File类、递归】-笔记1
08-04
Java File类和递归的使用 Java File类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。File类提供了多种构造方法和常用方法，用于获取文件和目录的信息。 File类的构造方法 File类...
Java基础知识-day08【File类、递归】.pdf
最新发布
10-26
Java基础知识-day08【File类、递归】 本节课主要讲解了Java中的File类和递归编程的知识点。 File类 Java中的File类是java.io包下的一个类，代表了文件和目录路径名的抽象表示。主要用于文件和目录的创建、查找和...
day08_File、递归、FileFilter2
08-08
1. **File类的使用**：在Java中，`File`类是用于表示文件和目录路径名的抽象表示。通过`File`对象，我们可以创建、删除、重命名文件和目录，以及获取文件的基本信息。在描述中提到了创建文件、检查文件存在、创建...
day08-File&递归&字节流
06-10
day08-File&递归&字节流
day08_File、递归、FileFilter-答案1
08-08
- **构造方法**：File类的构造方法允许我们根据路径创建File对象，例如`new File(String path)`用于创建绝对路径的File对象，`new File(String parent, String child)`用于创建相对于指定父路径的File对象。...
使用递归生成文件目录树
12-16
使用递归生成文件目录树 .txt 使用递归生成文件目录树 .txt
复习JavaFile类_递归_综合案例
菜鸡逆袭的博客
10-04 204
复习File类_递归 主要内容 File类 递归 第一章 File类 1.1 概述 java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作, 这里需要注意一点File不能用于对文件内容进行操作, 对文件内容进行操作需要使用FileInputStream与FileOutputStream。 1.2 构造方法 注: 构造File对象的时候要注意传入的参...
Java——递归文件目录
凌风暨
11-18 913
//递归：函数自己调用自己 //注意：1、避免内存溢出 2、要有结束调用的条件 import java.io.*; class test{ /* //什么是递归？ public static void main(String[] args){ //求1---num的和 add(3); } //求1---num的和 publ
java 递归文件夹_java递归实现复制一个文件夹下所有文件功能
weixin_35084652的博客
02-12 240
今天开始学习java的IO，学了一个复制文件的例子程序后想自己实现以下如何复制一个文件夹，复制文件的例子程序如下：package io.github.liuzhan214;import java.io.File;import java.io.IOException;public class Main {void solve() {File file = new File("F:\\javaIOTe...
java递归创建目录_java递归生成目录树
weixin_31661121的博客
02-12 462
一、创建实体类public class TreeNode {protected int id;protected int parentId;protected int level;protected String name;protected String code;protected String type;protected List children = new ArrayList<&...
Java基础-file和递归
qq_37948985的博客
05-29 329
学习目标： File IO概述 回想之前写过的程序，数据都是在内存中，一旦程序运行结束，这些数据都没有了，等下次再想使用这些数据，可是已经没有了。那怎么办呢？能不能把运算完的数据都保存下来，下次程序启动的时候，再把这些数据读出来继续使用呢？其实要把数据持久化存储，就需要把内存中的数据存储到内存以外的其他持久化设备(硬盘、光盘、U盘等)上。 当需要把内存中的数据存储到持久化设备上这个动作称为输出（写）Output操作。 当把持久设备上的数据读取到内存中的这个动作称为输入（读）Input操.
java File类 递归
myjess’s blog
02-12 819
文章目录第一章 File类1.1 概述1.2 构造方法1.3 常用方法1.4 目录的遍历第二章 递归2.1 概述2.2 递归累加求和2.3 递归打印多级目录第三章 综合案例3.1 文件搜索3.2 文件过滤器优化3.3 Lambda优化 第一章 File类 1.1 概述 java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作 1.2 构造方法 publi...
Java中File类与递归
qq_39926166的博客
12-23 254
File类 File类是文件目录路径抽象表示,主要用于文件和目录创建/查找/删除等操作 构造方法 a File(String path) : 通过将给定的路径字符串转换为抽象路径名来创建 file 实例 b File(String FatherPath, String SonPath): 从父路径名字字符串和子路径字符串创建新的 File 实例 c File(File FatherPath, String Sonpath) : 从抽象路径名和子路径名字字符串创建新的 File 实例 如:
理解java递归思想，通过递归实现文件夹下文件的遍历
每一件自己觉得值得的事都要不留余力的去做
08-30 2014
1.概述 程序调用自身的编程技巧称为递归（ recursion） 2.递归思想 递归就是方法里调用自身 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口 递归算法代码显得很简洁，但递归算法解题的运行效率较低。所以不提倡用递归设计程序。 在递归调用的过程中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等，所以一般不提倡用递归算法设计程序。 ...
用JAVA实现：在day19文件夹下操作： 1.创建task02 目录 2.使用集合List去存储如下数据(以Map形式，且以逗号为分隔符 ) task02，test01，File类操作.avi ，File 学习笔记.md ，Test02 ，java学院-讲师上云-日期讲解.avi ，java学院-讲师上云-日期解析.avi ，任务作业.txt 。其中task02是一级目录，test01和Test02以及"任务作业.txt”都是二级目录，"File类操作.avi"和“File学习笔记.md”是test01文件夹中的文件，“java学院-讲师上云-日期讲解.avi”和"java学院-讲师上云-日期解析.avi"都是Test02文件夹中的文件。将list 中的这些数据创建出对应的文件及其文件夹
06-12
file1.put("path", "./day19/task02/test01"); fileList.add(file1); Map, String> file2 = new HashMap(); file2.put("name", "File学习笔记.md"); file2.put("path", "./day19/task02/test01"); fileList....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值