Java文件操作 总结

1、相对路径和绝对路径

/*
* 绝对路径：是一个完整的路径，以盘符开始的路径
* 例如：C:\Users\86188\Desktop\码农之路\Java\FILE\123.txt
* 相对路径：是一个简化的路径，指的是相对于当前项目的根目录
* 例如：可简化为123.txt
* 注意：
* 1.路径是不区分大小写的
* 2.路径中的文件名称分隔符，在window系统下是反斜杠\，两个反斜杠代表一个普通的反斜杠
*/

2、分隔符

String pathSeparator= File.pathSeparator;
        System.out.println(pathSeparator);//路径分隔符，在windows系统下是分号，在linux系统下是冒号

        String separator=File.separator;
        System.out.println(separator);//文件名称分隔符，在window系统下是反斜杠\,在linux系统下是正斜杠/

3、File类的构造方法

/*
* 1、File(String pathname)
* 通过将给定路径名字字符串转换为抽象路径名来创建一个新File实例
* 参数是字符串的路径名称
* 路径可以是文件结尾，也可以是文件夹结尾
* 路径可以是相对的，也可以是绝对的
* 路径可以是存在的，也可以是不存在的
* 创建File对象，只是把字符串路径封装成File对象，不考虑路径的真假情况
*
*
*
* 2、File(String parent,String child)
* 根据parent路径名字符串和child路径名字符串创建一个新的File实例
* 参数：把路径分成了两部分
* 1.String parent:父路径
* 2.String child:子路径
* 好处：
* 1.父路径和子路径，可以单独书写，使用起来很灵活，父路径和子路径都可以变化
*
*
*
* 3、File(File parent,String child)
* 根据parent抽象路径名和child路径名字符串创建一个新File实例
* 参数：把路径分成两部分
* 1.File parent:父路径
* 2.String child:子路径
* 好处：
* 1.父路径和子路径，可以单独书写，使用起来很灵活，父路径和子路径都可以变化
* 2.父路径是File类型，可以使用File的方法对路径进行一些操作，再使用路径创建对象
*
*/

代码实现

import java.io.File;

/**
 * @author Ethan Xu
 * @date 2023/4/20 18:11
 * Talk is cheap,show me code.
 */

public class demo3 {
    //1、public String getAbsolutePath()
    public static void show1(){
        File f1=new File("C:\\Users\\86188\\Desktop\\码农之路\\Java\\FILE\\123.txt");//获取的构造方法中传递的路径是绝对路径
        String absolutePath1=f1.getAbsolutePath();
        System.out.println(absolutePath1);

        File f2=new File("123.txt");//获取的构造方法中传递的路径是相对路径
        String absolutePath2=f2.getAbsolutePath();
        System.out.println(absolutePath2);
    }

    //2、public String getPath()
    public static void show2(){
        File f1=new File("C:\\User\\86188\\Desktop\\码农之路\\Java\\FILE\\123.txt");
        String path1=f1.getPath();
        System.out.println(path1);

        File f2=new File("123.txt");
        String path2=f2.getPath();
        System.out.println(path2);
    }

    //3、public String getName()
    public static void show3(){
        File f1=new File("C:\\User\\86188\\Desktop\\码农之路\\Java\\FILE\\123.txt");//结尾是文件
        String name1=f1.getName();
        System.out.println(name1);

        File f2=new File("C:\\User\\86188\\Desktop\\码农之路\\Java\\FILE");//结尾是文件夹
        String name2=f2.getName();
        System.out.println(name2);
    }

    //4、public long length()
    public static void show4(){
        File f1=new File("C:\\Users\\86188\\Desktop\\头像\\11111.jpg");//路径存在
        long length1=f1.length();
        System.out.println(length1);

        File f2=new File("C:\\User\\86188\\Desktop\\码农之路\\Java\\FILE\\demo1.java");//路径不存在,返回0
        long length2=f2.length();
        System.out.println(length2);

        File f3=new File("C:\\User\\86188");//路径结尾是文件夹，没有大小之分，返回0
        long length3=f3.length();
        System.out.println(length3);
    }

    //测试程序
    public static void main(String[] args){
        System.out.println("*1、public String getAbsolutePath()");
        show1();
        System.out.println();

        System.out.println("*2、public String getPath()");
        show2();
        System.out.println();

        System.out.println("* 3、public String getName()");
        show3();
        System.out.println();

        System.out.println("* 4、public long length()");
        show4();
        System.out.println();
    }
}

运行结果

4、File类获取功能的方法

/*
* File类获取功能的方法
*
* 1、public String getAbsolutePath()
* 返回此File的绝对路径名字符串
* 获取的构造方法中传递的路径无论是绝对的还是相对的，getAbsolutePath方法返回的都是绝对路径
*
* 2、public String getPath()
* 将此File转换为路径名字符串
* 获取的构造方法中传递的路径是什么样的就返回什么样的
*
* 3、public String getName()
* 返回由此File表示的文件或目录的名称
* 获取的就是构造方法传递路径的结尾部分（文件/文件夹）
*
*
* 4、public long length()
* 返回由此File表示的文件的长度
* 获取的是构造方法指定的文件的大小，以字节为单位
* 注意：
* 1.文件夹是没有大小概念的，不能获取文件夹的大小
* 2. 如果构造方法中给出的路径不存在，那么 length方法返回0
*
*/
代码实现

import java.io.File;

/**
 * @author Ethan Xu
 * @date 2023/4/20 18:11
 * Talk is cheap,show me code.
 */

public class demo3 {
    //1、public String getAbsolutePath()
    public static void show1(){
        File f1=new File("C:\\Users\\86188\\Desktop\\码农之路\\Java\\FILE\\123.txt");//获取的构造方法中传递的路径是绝对路径
        String absolutePath1=f1.getAbsolutePath();
        System.out.println(absolutePath1);

        File f2=new File("123.txt");//获取的构造方法中传递的路径是相对路径
        String absolutePath2=f2.getAbsolutePath();
        System.out.println(absolutePath2);
    }

    //2、public String getPath()
    public static void show2(){
        File f1=new File("C:\\User\\86188\\Desktop\\码农之路\\Java\\FILE\\123.txt");
        String path1=f1.getPath();
        System.out.println(path1);

        File f2=new File("123.txt");
        String path2=f2.getPath();
        System.out.println(path2);
    }

    //3、public String getName()
    public static void show3(){
        File f1=new File("C:\\User\\86188\\Desktop\\码农之路\\Java\\FILE\\123.txt");//结尾是文件
        String name1=f1.getName();
        System.out.println(name1);

        File f2=new File("C:\\User\\86188\\Desktop\\码农之路\\Java\\FILE");//结尾是文件夹
        String name2=f2.getName();
        System.out.println(name2);
    }

    //4、public long length()
    public static void show4(){
        File f1=new File("C:\\Users\\86188\\Desktop\\头像\\11111.jpg");//路径存在
        long length1=f1.length();
        System.out.println(length1);

        File f2=new File("C:\\User\\86188\\Desktop\\码农之路\\Java\\FILE\\demo1.java");//路径不存在,返回0
        long length2=f2.length();
        System.out.println(length2);

        File f3=new File("C:\\User\\86188");//路径结尾是文件夹，没有大小之分，返回0
        long length3=f3.length();
        System.out.println(length3);
    }

    //测试程序
    public static void main(String[] args){
        System.out.println("*1、public String getAbsolutePath()");
        show1();
        System.out.println();

        System.out.println("*2、public String getPath()");
        show2();
        System.out.println();

        System.out.println("* 3、public String getName()");
        show3();
        System.out.println();

        System.out.println("* 4、public long length()");
        show4();
        System.out.println();
    }
}

运行结果

5、File类判断功能的方法

/*
* 1、public boolean exists()
* 判断此File表示的文件或目录是否实际存在
* 用于判断构造方法中传递的路径是否存在，存在则返回 true,不存在则返回 false
*
*
* 2、public boolean isDirectory()
* 判断此File表示的是否为目录
* 用于判断构造方法中给定的路径是否以文件夹结尾,是则返回 true,否则返回 false
*
* 3、public boolean isFile()
* 判断此File表示的是否为文件
* 用于判断构造方法中给定的路径是否以文件结尾,是则返回 true,否则返回 false
* 注意：
* 1.电脑的硬盘中只有文件/文件夹，两个方法是互斥的
* 2.这两个方法的使用前提是，路径必须是存在的，否则都返回 false,所以使用的时候一般会先用 exists()判断是否存在
*
*/
代码实现

import java.io.File;

/**
 * @author Ethan Xu
 * @date 2023/4/20 20:27
 * Talk is cheap,show me code.
 */

public class demo4 {

    //1、public boolean exists()
    public static void show1(){
        File f1=new File("C:\\Users\\86188\\Desktop\\码农之路\\Java");//路径存在，返回true
        System.out.println(f1.exists());

        File f2=new File("C:\\Users\\86111");//路径不存在,返回false
        System.out.println(f2.exists());

        File f3=new File("FILE.iml");//相对路径也可以
        System.out.println(f3.exists());
    }

    //2、public boolean isDirectory()
    public static void show2(){

        File f1=new File("C:\\Users\\86188\\Desktop\\码农之路\\Java");//以文件夹结尾
        if(f1.exists()){
            System.out.println(f1.isDirectory());
        }

        File f2=new File("FILE.iml");//以文件结尾
        if(f2.exists()){
            System.out.println(f2.isDirectory());
        }

    }

    //3、public boolean isFile()
    public static void show3(){
        File f1=new File("C:\\Users\\86188\\Desktop\\码农之路\\Java");//以文件夹结尾
        if(f1.exists()){
            System.out.println(f1.isFile());
        }

        File f2=new File("FILE.iml");//以文件结尾
        if(f2.exists()){
            System.out.println(f2.isFile());
        }

    }

    //测试程序
    public static void main(String[] args){
        System.out.println("* 1、public boolean exists()");
        show1();
        System.out.println();

        System.out.println("*2、public boolean isDirectory()");
        show2();
        System.out.println();

        System.out.println("* 3、public boolean isFile()");
        show3();
        System.out.println();
    }
}

运行结果

6、File类创建删除功能的方法

/*
* 1、public boolean createNweFile()
* 当且仅当具有该名称的文件尚不存在时，创建一个新的空文件
* 创建文件的路径和名称在构造方法中给出（构造方法的参数）
* 返回值：
* 1.文件不存在时，创建文件，返回true
* 2.文件存在，不会创建，返回false
* 注意：
* 1. 此方法只能创造文件，不能创造文件夹
* 2. 创建文件的路径必须存在，否则会抛出异常
* 3. createNewFile声明抛出了IOException，我们调用这个方法时，必须处理这个异常，要么throws,要么trycatch
*
*
*
* 2、public boolean delete()
* 删除由此File表示的文件或目录
* 删除构造方法路径中给出的文件/文件夹
* 返回值：
* 1.文件/文件夹删除成功，返回true
* 2.文件夹中有内容，不会删除，返回false
* 3.构造方法中路径不存在，返回false
* 注意：
* 1. delete方法是直接在硬盘上删除文件/文件夹，不走回收站，删除的时候要谨慎
*
*
*
* 3、public boolean mkdir()
* 创建由此File表示的目录
* 创建单级文件夹
* 创建文件夹的路径和名称在构造方法中给出（构造方法的参数）
* 返回值：
* 1.文件夹不存在，创建文件夹，返回 true
* 2.文件夹存在，不会创建，返回 false
* 3.构造方法中给出的路径不存在，返回 false
* 注意：
* 1. 此方法只能创建文件夹，不能创建文件
*
*
*
* 4、public boolean mkdirs()
* 创建由此File表示的目录，包括任何必需但不存在的父目录
* 既可以创建单级文件夹，也可以创造多级文件夹
* 创建文件夹的路径和名称在构造方法中给出（构造方法的参数）
* 返回值：
* 1.文件夹不存在，创建文件夹，返回 true
* 2.文件夹存在，不会创建，返回 false
* 3. 构造方法中给出的路径不存在，返回 false
* 注意：
* 1. 此方法只能创建文件夹，不能创建文件
*
*
*
*/

代码实现

import java.io.File;
import java.io.IOException;

/**
 * @author Ethan Xu
 * @date 2023/4/20 21:02
 * Talk is cheap,show me code.
 */


public class demo5 {

    //1、public boolean createNweFile()
    public static void show1 ()throws IOException {//throws IOExpection
        File f1=new File("C:\\Users\\86188\\Desktop\\头像\\123.txt");//路径存在，且当前没有这个名字的文件，创建了一个，名为123的.txt文件
        boolean b1=f1.createNewFile();
        System.out.println("b1:"+b1);

        File f2=new File("C:\\Users\\86189");//路径不存在，直接抛出IOException
        boolean b2=f2.createNewFile();
        System.out.println("b2:"+b2);
    }


    //2、public boolean delete()
    public static void show2(){
        File f1=new File("C:\\Users\\86188\\Desktop\\头像\\123.txt");//删除名为123.txt的文件
        boolean b1=f1.delete();
        System.out.println("b1:"+b1);
    }

    //3、public boolean mkdir()
    public static void show3(){
        File f1=new File("C:\\Users\\86188\\Desktop\\头像\\aaa");//路径存在，创建了一个名为aaa的文件夹
        boolean b1=f1.mkdir();
        System.out.println("b1:"+b1);
    }


    //4、public boolean mkdirs()
    public static void show4(){
        File f1=new File("C:\\Users\\86188\\Desktop\\头像\\111\\222\\333");//路径存在，在头像文件夹里创建了一个名为111的文件夹，在名为111的文件夹里创建了一个名为222的文件夹，在名为222的文件夹里创建了一个名为333的文件夹
        boolean b1=f1.mkdirs();
        System.out.println("b1:"+b1);
    }





    //测试程序
    public static void main(String[] args) throws IOException{
        System.out.println("* 1、public boolean createNweFile()");
        show1();
        System.out.println();


        System.out.println("* 2、public boolean delete()");
        show2();
        System.out.println();


        System.out.println("* 3、public boolean mkdir()");
        show3();
        System.out.println();


        System.out.println("* 4、public boolean mkdirs()");
        show4();
        System.out.println();
    }
}

运行结果

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

/*
* 1、public String[] list()
* 返回一个String数组，表示该File目录中的所有子文件或目录
* 遍历构造方法中给出的目录，会获取目录中所有文件/文件夹的名称，把获取到的多个名称存储到一个String类型的数组中
*
*
*
* 2、public File[] listFiles()
* 返回一个File数组，表示该File目录中的所有的子文件或目录
* 遍历构造方法中给出的目录，会获取目录中的所有文件/文件夹，把文件/文件夹封装为File对象，多个File对象存储到File数组中
* 会获取该目录下的所有文件/文件夹，但是不会获取子文件夹中的文件/文件夹
*
*
*
* 注意：
* 1. list方法和listFile方法遍历的是构造方法中给出的目录
* 2. 如果构造方法中给出的目录的路径不存在，则会抛出空指针异常
* 3. 如果构造方法中给出的路径不是一个目录，也会抛出空指针异常
*
* */
代码实现

import java.io.File;

/**
 * @author Ethan Xu
 * @date 2023/4/21 22:38
 * Talk is cheap,show me code.
 */


public class demo6 {

    //1、public String[] list()
    public static void show1(){
        File f1=new File("C:\\Users\\86188\\Desktop\\头像");//遍历头像文件夹中的所有子文件
        String[] arr=f1.list();
        for(String filename:arr){
            System.out.println(filename);
        }
    }

    //2、public File[] listFiles()
    public static void show2(){
        File f1=new File("C:\\Users\\86188\\Desktop\\HAUTcourse\\软件工程概论");
        File[] files=f1.listFiles();
        for(File f:files){
            System.out.println(f);
        }

    }



    //测试程序
    public static void main(String[] args){

        System.out.println("* 1、public String[] list()");
        show1();
        System.out.println();

        System.out.println("* 2、public File[] listFiles()");
        show2();
        System.out.println();


    }
}

运行结果

8、递归打印多级目录

代码实现

import java.io.File;

/**
 * @author Ethan Xu
 * @date 2023/4/21 23:01
 * Talk is cheap,show me code.
 */

/*
    *递归打印多级目录
    *  */
public class demo7 {

    //定义一个方法，参数传递File类型的目录
    //方法中对目录进行遍历

    public static void getAllFile(File dir){
        File[] files=dir.listFiles();
        for(File f:files){
            //对遍历得到的File对象f进行判断，判断是否是文件夹
            if(f.isDirectory()){
                //如果f是一个文件夹，则继续遍历这个文件夹
                //getAllFile方法自己调用自己
                getAllFile(f);
            }else{
                //如果不是一个文件夹，则直接打印即可
                System.out.println(f);
            }
        }
    }
    public static void main(String[] args){
        File file=new File("C:\\Users\\86188\\Desktop\\HAUTcourse\\软件工程概论");
        getAllFile(file);
    }
}

运行结果

9、文件搜索

/*
* 以搜索C:\Users\86188\Desktop\HAUTcourse\C++\课程设计，中的.doc文件为例
* 在递归打印多级目录上，做了一点修改
* */
代码实现

import java.io.File;

/**
 * @author Ethan Xu
 * @date 2023/4/21 23:21
 * Talk is cheap,show me code.
 */

public class demo8 {

    //定义一个方法，参数传递File类型的目录
    //方法中对目录进行遍历

    public static void getAllFile(File dir){
        File[] files=dir.listFiles();
        for(File f:files){
            //对遍历得到的File对象f进行判断，判断是否是文件夹
            if(f.isDirectory()){
                //如果f是一个文件夹，则继续遍历这个文件夹
                //getAllFile方法自己调用自己
                getAllFile(f);
            }else{
                //如果不是一个文件夹，则直接打印即可
               /* 现在只想要.doc文件
               1、把File对象f，转换为字符串对象(三种方法)
                    String name=f.getName();
                    String path=f.getPath();
                    String s=f.toString();

               2、调用String类中的方法endsWitch判断字符串是否是以.doc结尾

               3、如果是以.doc结尾的文件，则输出
               * */
                String s=f.toString();
                //这样做有一个缺点，就是后缀名如果是大写，其实也是.doc文件，但是获取不到了。所以最好加个转换为小写
                s=s.toLowerCase();
                boolean b=s.endsWith(".doc");

                if(b){
                    System.out.println(f);
                }
            }
        }
    }
    public static void main(String[] args){
        File file=new File("C:\\Users\\86188\\Desktop\\HAUTcourse\\C++\\课程设计");
        getAllFile(file);
    }
}

运行结果

10、文件搜索（过滤器）

/*
* 使用过滤器来实现
* 在File类中有两个和listFiles重载的方法。方法的参数传递的就是过滤器
* 1、File[] listFiles(FileFilter filter)
* java.io.FileFilter接口：用于抽象路径名（File对象）的过滤器
* 作用：用来过滤文件（File对象）
* 抽象方法：用来过滤文件的方法
* 1. boolean accept(File pathname) 测试指定抽象路径名是否应该包含在某个路径名列表中
* 2.参数：
* File pathname:使用ListFiles方法遍历目录，得到的每一个文件对象
*
*
* 2、File[] listFiles(FilenameFilter filter)
* java.io.FilenameFilter接口：实现此接口的类实例可用于过滤文件名
* 作用：用于过滤文件名称
* 抽象方法：用来过滤文件的方法
* 1. boolean accept(File dir,String name)测试指定文件是否应该包含在某一文件列表中
* 2.参数：
* File dir：构造方法中传递的被遍历的目录
* String name:使用ListFiles方法遍历目录，获取的每一个文件/文件夹的名称
*
*
* 注意：
* 1.两个过滤器接口是没有实现类的，需要我们自己写实现类，重写过滤方法accept，在方法中自己定义过滤的规则
*
*
*
* */

1.第一种过滤器

构造实例类实现

代码实现

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

/**
 * @author Ethan Xu
 * @date 2023/4/21 23:35
 * Talk is cheap,show me code.
 */

//创建过滤器FileFilter的实现类，重写过滤方法accept，定义过滤规则
class FileFilterImp1 implements FileFilter {

    @Override
    public boolean accept(File pathname) {
        /*
        * 过滤的规则：
        * 在accept方法中，判断File对象是否是以.doc结尾
        * 是，则返回true
        * 不是，则返回false
        */
        /*但是这样的话，如果pathname是一个文件夹，那也会被过滤，因为它不是.doc结尾的文件
        所以，如果pathname是一个文件夹，也让它返回true，继续遍历这个文件夹
        */
        if(pathname.isDirectory()){
            return true;
        }
        return pathname.getName().toLowerCase().endsWith(".doc");
    }
}
public class demo9 {

    //定义一个方法，参数传递File类型的目录
    //方法中对目录进行遍历

    public static void getAllFile(File dir){
        File[] files=dir.listFiles(new FileFilterImp1());//传递了一个过滤器对象
        for(File f:files){
            //对遍历得到的File对象f进行判断，判断是否是文件夹
            if(f.isDirectory()){
                //如果f是一个文件夹，则继续遍历这个文件夹
                //getAllFile方法自己调用自己
                getAllFile(f);
            }else{
                //如果不是一个文件夹，则直接打印即可
                System.out.println(f);
            }
        }
    }
    public static void main(String[] args){
        File file=new File("C:\\Users\\86188\\Desktop\\HAUTcourse\\C++\\课程设计");
        getAllFile(file);
    }
}

运行结果

匿名内部类实现（Lambda表达式优化）

代码实现

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

/**
 * @author Ethan Xu
 * @date 2023/4/22 0:36
 * Talk is cheap,show me code.
 */

//第一种过滤器，使用匿名内部类实现
//使用Lambda表达式优化
public class demo10 {
    //定义一个方法，参数传递File类型的目录
    //方法中对目录进行遍历

    public static void getAllFile(File dir){
        /*传递过滤器对象，使用匿名内部类
        File[] files=dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                *//*过滤规则：
                * pathname是文件夹或者是.doc结尾的文件则返回true
                *//*
                return pathname.isDirectory()||pathname.getName().toLowerCase().endsWith(".doc");
            }
        });
        */

        /*第一个过滤器接口中，只有一个accpet抽象方法，
        所以也可以使用Lambda表达式优化匿名内部类（Lambda表达式使用范围是接口中只有一个抽象方法）
        */
        File[] files=dir.listFiles((File pathname)->{
                return pathname.isDirectory()||pathname.getName().toLowerCase().endsWith(".doc");
        });
        for(File f:files){
            //对遍历得到的File对象f进行判断，判断是否是文件夹
            if(f.isDirectory()){
                //如果f是一个文件夹，则继续遍历这个文件夹
                //getAllFile方法自己调用自己
                getAllFile(f);
            }else{
                //如果不是一个文件夹，则直接打印即可
                System.out.println(f);
            }
        }
    }
    public static void main(String[] args){
        File file=new File("C:\\Users\\86188\\Desktop\\HAUTcourse\\C++\\课程设计");
        getAllFile(file);
    }
}

运行结果

2.第二种过滤器

匿名内部类实现（Lambda表达式优化）

代码实现

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

/**
 * @author Ethan Xu
 * @date 2023/4/22 0:42
 * Talk is cheap,show me code.
 */

//第二种过滤器，使用匿名内部类实现
//使用Lambda表达式优化
public class demo11 {
    //定义一个方法，参数传递File类型的目录
    //方法中对目录进行遍历

    public static void getAllFile(File dir){
        /*//传递过滤器对象，使用匿名内部类
        File[] files=dir.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir,String name) {
                *//*过滤规则：
                 * pathname是文件夹或者是.doc结尾的文件则返回true
                 *//*
                return new File(dir,name).isDirectory()||name.toLowerCase().endsWith(".doc");
            }
        });*/

        /*第二个过滤器接口中，只有一个accpet抽象方法，
        所以也可以使用Lambda表达式优化匿名内部类（Lambda表达式使用范围是接口中只有一个抽象方法）
        */
        //传递过滤器对象，使用匿名内部类
        File[] files=dir.listFiles((File d,String name)-> {
                /*过滤规则：
                 * pathname是文件夹或者是.doc结尾的文件则返回true
                 */
                return new File(d,name).isDirectory()||name.toLowerCase().endsWith(".doc");

        });

        for(File f:files){
            //对遍历得到的File对象f进行判断，判断是否是文件夹
            if(f.isDirectory()){
                //如果f是一个文件夹，则继续遍历这个文件夹
                //getAllFile方法自己调用自己
                getAllFile(f);
            }else{
                //如果不是一个文件夹，则直接打印即可
                System.out.println(f);
            }
        }
    }
    public static void main(String[] args){
        File file=new File("C:\\Users\\86188\\Desktop\\HAUTcourse\\C++\\课程设计");
        getAllFile(file);
    }
}

运行结果