JavaSE——File类详解(递归查找文件)

已于 2024-10-23 19:23:31 修改
阅读量1.1k 收藏 8
点赞数 18
分类专栏： # JavaSE 文章标签： java IO流 File 递归
于 2024-10-19 09:24:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Helen_1997_1997/article/details/133150054
版权

目录

一、File类的概述

二、File的三种构造方法

三、File类常见的成员方法

(一)判断、获取

1.判断的方法 

2.获取的方法

(二)创建、删除

(三)获取并遍历

(四)所有获取并遍历的方法

(五)常用方法总结

四、分隔符

五、File类操作文件与递归(重要)

(一)创建文件

(二)单个文件夹查找文件

(三)递归遍历硬盘查找文件

(四)递归删除文件夹

(五)统计文件夹总大小

(六)统计各种文件数量(重要)

(七)统计指定文件的个数

一、File类的概述

        File对象表示一个路径，可以是文件的路径，也可以是文件夹的路径。这个路径可以是存在的，也可以是不存在的。

        绝对路径：带盘符的。

        相对路径：不带盘符的。

        File类的弊端：只能对文件本身进行操作，不能读写文件里面存储的数据。

二、File的三种构造方法

public File(String pathname)

根据文件路径创建文件对象

即：把字符串表示的路径变成File对象

public File(String parent, String child)

根据父路径名字符串，和子路径名字符串创建文件对象

即：把父级路径和子级路径进行拼接

public File(File parent, String child)

根据父路径对应文件对象，和子路径名字符串创建文件对象

即：把父级路径和子级路径进行拼接

public class FileDemo1 {
    public static void main(String[] args) {
        // 1.根据字符串表示的路径，变成File对象
        String str = "C:\\Users\\alienware\\Desktop\\a.txt";
        File f1 = new File(str);
        System.out.println(f1);
        // C:\Users\alienware\Desktop\a.txt

        // 2.父级路径：C:\Users\alienware\Desktop
        //   子级路径：a.txt
        String parent = "C:\\Users\\alienware\\Desktop";
        String child = "a.txt";
        File f2 = new File(parent, child);
        System.out.println(f2);
        // C:\Users\alienware\Desktop\a.txt

        // 下面的操作不建议：因为不同的操作系统下，磁盘分隔符不同
        // windows：\(反斜杠)    linux和macOS：/(正斜杠)
        File f3 = new File(parent + "\\" + child);
        System.out.println(f3);
        // C:\Users\alienware\Desktop\a.txt

        // 文件拼接 建议用File.separator的方式：
        String directory = "documents";
        String subDirectory = "projects";
        String filename = "report.pdf";
        String filePath1 = directory + File.separator + subDirectory + File.separator + filename;
        // 或者
        String filePath2 = "documents" + File.separator + "documents" + File.separator + "report.pdf";
        File file1 = new File(filePath1);
        File file2 = new File(filePath2);
        // file.getAbsolutePath()：返回调用该方法时File对象所表示的文件或目录的绝对路径
        System.out.println(file1.getAbsolutePath());
        System.out.println(file2.getAbsolutePath());
        // G:\develop\workspace\one\basecode\documents\projects\report.pdf
        
        // 3.把一个File表示的路径和String表示路径进行拼接
        File parent2 = new File("C:\\Users\\alienware\\Desktop");
        String child2 = "a.txt";
        File f4 = new File(parent2, child2);
        System.out.println(f4);
        // C:\Users\alienware\Desktop\a.txt
    }
}

三、File类常见的成员方法

(一)判断、获取

1.判断的方法 

public class FileDemo2 {
    public static void main(String[] args) {
        // 1.对一个文件的路径进行判断
        File f1 = new File("D:\\test\\a.txt");
        System.out.println(f1.isDirectory()); // false
        System.out.println(f1.isFile()); // true
        System.out.println(f1.exists()); // true

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

        // 2.对一个文件夹进行判断
        File f2 = new File("D:\\test\\bbb");
        System.out.println(f2.isDirectory()); // true
        System.out.println(f2.isFile()); // false
        System.out.println(f2.exists()); // true

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

        // 3.对一个不存在的路径进行判断
        File f3 = new File("D:\\test\\ddd");
        System.out.println(f3.isDirectory()); // false
        System.out.println(f3.isFile()); // false
        System.out.println(f3.exists()); // false
    }
}

2.获取的方法

public class FileDemo3 {
    public static void main(String[] args) {     
        // 1.length  返回文件的大小(字节数量)
        // 细节1：这个方法只能获取文件的大小，单位是字节
        // 如果单位想要M，G，可以不断的除以1024
        // 细节2：这个方法无法获取[文件夹]的大小
        // 如果我们要获取一个文件夹的大小，需要把这个文件夹里面所有的文件大小都累加在一起。

        File f1 = new File("D:\\test\\a.txt");
        long len = f1.length();
        System.out.println(len); // 970

        File f2 = new File("D:\\test\\bbb");
        long len2 = f2.length();
        System.out.println(len2); // 0

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

        // 2.getAbsolutePath 返回文件的绝对路径
        File f3 = new File("D:\\test\\a.txt");
        String path1 = f3.getAbsolutePath();
        System.out.println(path1);
        // D:\test\a.txt

        File f4 = new File("chapter16\\a.txt");
        String path2 = f4.getAbsolutePath();
        System.out.println(path2);
        // G:\develop\workspace\one\basecode\chapter16\a.txt

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

        // 3.getPath 返回定义文件时使用的路径
        // 即：new File()中是什么就返回什么
        File f5 = new File("D:\\test\\a.txt");
        String path3 = f5.getPath();
        System.out.println(path3);
        // D:\test\a.txt

        File f6 = new File("chapter16\\a.txt");
        String path4 = f6.getPath();
        System.out.println(path4);
        // chapter16\a.txt

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

        // 4.getName 返回文件的名称，带后缀
        // 如果是文件，就返回文件名+后缀名
        // 如果是文件夹，就返回文件夹的名字
        File f7 = new File("D:\\test\\a.txt");
        String name1 = f7.getName();
        System.out.println(name1);
        // a.txt  文件名+后缀名

        File f8 = new File("D:\\test\\bbb");
        String name2 = f8.getName();
        System.out.println(name2);
        // bbb

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

        // 5.lastModified 返回文件的最后修改时间（时间毫秒值）
        File f9 = new File("D:\\test\\a.txt");
        long lastModified = f9.lastModified();
        System.out.println(lastModified);
        // 1729183893084   毫秒值

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(lastModified);
        System.out.println(format);
        // 2024-10-18 00:51:33
    }
}

(二)创建、删除

注意：delete方法默认只能删除文件和空文件夹，直接删除不走回收站

public class FileDemo4 {
    public static void main(String[] args) throws IOException {
        // 1.createNewFile 创建一个新的空的文件
        // 细节1：如果当前路径表示的文件是不存在的，则创建成功，方法返回true
        //       如果当前路径表示的文件是存在的，则创建失败，方法返回false
        // 细节2：如果父级路径是不存在的，那么方法会有异常IOException
        // 细节3：createNewFile方法创建的一定是文件，如果路径中不包含后缀名，则创建一个没有后缀的文件
        File file = new File("D:\\test\\aaa\\c.txt");
        boolean newFile = file.createNewFile();
        System.out.println(newFile); 

        // 2.mkdir   make Directory，文件夹（目录）
        // 细节1：windows当中路径是唯一的，如果当前路径已经存在，则创建失败，返回false
        // 细节2：mkdir方法只能创建单级文件夹，无法创建多级文件夹。
        File file2 = new File("D:\\test\\aaa");
        boolean mkdir = file2.mkdir();
        System.out.println(mkdir);

        // 3.mkdirs   创建多级文件夹
        // 细节：既可以创建单级的，又可以创建多级的文件夹
        File file3 = new File("D:\\test\\aaa\\bbb\\ccc");
        File file3 = new File("D:\\test\\ggg");
        boolean mkdirs = file3.mkdirs();
        System.out.println(mkdirs);

        /*
           4.delete    删除文件、文件夹
        细节：
            如果删除的是文件，则直接删除，不走回收站。
            如果删除的是空文件夹，则直接删除，不走回收站
            如果删除的是有内容的文件夹，则删除失败
      */
        // 1.创建File对象
        File f1 = new File("D:\\test\\aaa");
        // 2.删除
        boolean b = f1.delete();
        System.out.println(b);
    }
}

(三)获取并遍历

public File[] listFiles()        获取当前该路径下所有内容

  1. 当调用者File表示的路径不存在时，返回NullPointerException
  2. 当调用者File表示的路径是文件时，返回NullPointerException
  3. 当调用者File表示的路径是一个空文件夹时，返回一个长度为0的数组
  4. 当调用者File表示的路径是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回
  5. 当调用者File表示的路径是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
  6. 当调用者File表示的路径是需要权限才能访问的文件夹时，返回NullPointerException
public class FileDemo6 {
    public static void main(String[] args) {
        // 1.创建File对象
        File f = new File("D:\\test");
        // 2.listFiles方法
        //作用：获取aaa文件夹里面的所有内容，把所有的内容放到数组中返回
        File[] files1 = f.listFiles();
        for (File file : files1) {
            // file依次表示test文件夹里面的每一个文件或者文件夹
            System.out.println(file);
        }
    }
}

运行结果： 

(四)所有获取并遍历的方法

public class FileDemo7 {
    public static void main(String[] args) {
        // 1.listRoots  获取系统中所有的盘符
        File[] arr = File.listRoots();
        System.out.println(Arrays.toString(arr));
        // [C:\, D:\, E:\, G:\]

        // 2.list()    获取当前该路径下所有内容(仅仅能获取名字)
        File file = new File("D:\\test");
        String[] arr2 = file.list();
        System.out.println(Arrays.toString(arr2));
        // [a.avi, aaa, b.txt, bbb, c.txt, ccc, fff]

        // 3.list(FilenameFilter filter)  利用文件名过滤器获取当前该路径下所有内容
        // 需求：获取D:\\test文件夹里面所有的txt文件
        File file1 = new File("D:\\test");
        // accept方法的形参，依次表示test文件夹里面每一个文件或者文件夹的路径
        // 参数一：父级路径; 参数二：子级路径
        // 返回值：如果返回值为true，就表示当前路径保留
        //        如果返回值为false，就表示当前路径舍弃不要
        String[] arr3 = file1.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                File file2 = new File(dir, name);
                return file2.isFile() && name.endsWith(".txt");
            }
        });
        System.out.println(Arrays.toString(arr3));
        // [b.txt, c.txt]

        // lambda表达式
        String[] arr4 = file1.list((s1, s2) -> {
            File file2 = new File(s1, s2);
            return file2.isFile() && s2.endsWith(".txt");
        });
        System.out.println(Arrays.toString(arr4));
        // [b.txt, c.txt]
    }
}
public class FileDemo8 {
    public static void main(String[] args) {
        // 1.创建File对象
        File f = new File("D:\\test");

        // 2.需求：打印里面所有的txt文件
        File[] files = f.listFiles();
        for (File file : files) {
            if (file.isFile() && file.getName().endsWith(".txt")) {
                System.out.println(file);
            }
        }
        /**
         * D:\test\b.txt
         * D:\test\c.txt
         */
    }
}
public class FileDemo9 {
    public static void main(String[] args) {
        // 创建File对象
        File f = new File("D:\\test");
        // 调用listFiles(FileFilter filter)
        File[] arr = f.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.isFile() && pathname.getName().endsWith(".txt");
            }
        });
        System.out.println(Arrays.toString(arr));
        // [D:\test\b.txt, D:\test\c.txt]

        // lambda表达式
        File[] arr2 = f.listFiles((name) -> name.isFile() && name.getName().endsWith(".txt"));
        System.out.println(Arrays.toString(arr2));
        // [D:\test\b.txt, D:\test\c.txt]

        File[] arr3 = f.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                File file = new File(dir, name);
                return file.isFile() && name.endsWith(".txt");
            }
        });
        System.out.println(Arrays.toString(arr3));
        // [D:\test\b.txt, D:\test\c.txt]
    }
}

(五)常用方法总结

public class FileDemo2 {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\aa\\meinv.txt");
        // 创建文件
        file.createNewFile();
        // 判断是否是只读文件
        System.out.println(file.canWrite());
        // 判断文件或者目录是否存在
        System.out.println(file.exists());
        // 获取绝对路径
        System.out.println(file.getAbsolutePath());
        // 获取剩余空间 单位是字节
        System.out.println(file.getFreeSpace());
        // 获取可用空间
        System.out.println(file.getUsableSpace());
        // 获取总空间
        System.out.println(file.getTotalSpace());
        // 获取文件名
        System.out.println(file.getName());
        // 获取父路径
        System.out.println(file.getParent());
        // 获取路径
        System.out.println(file.getPath());
        // 判断是否是绝对路径
        System.out.println(file.isAbsolute());
        // 判断是否是文件
        System.out.println(file.isFile());
        // 判断是否是隐藏文件
        System.out.println(file.isHidden());
        // 获取修改时间到计算机元年的毫秒值
        System.out.println(file.lastModified());
        System.out.println(new Date(1729674265163L));

        // 返回true就会保留在数组中
        // 获取名称中带数字的文件或目录
        // 匿名内部类
        File[] files1 = file.listFiles(new FileFilter() {
        // 传入file对象
            @Override
            public boolean accept(File pathname) {
                return pathname.getName().matches(".*\\d.*");
            }
        });

        // lambda表达式
        File[] files2 = file.listFiles(f -> f.getName().matches(".*\\d.*"));

        // 匿名内部类
        File[] files3 = file.listFiles(new FilenameFilter() {
            // dir 文件所在的父目录
            // name 文件名称
            @Override
            public boolean accept(File dir, String name) {
                return name.matches(".*\\d.*");
            }
        });

        // lambda表达式
        File[] files4 = file.listFiles((dir, name) -> name.matches(".*\\d.*"));
        for (File f : files4) {
            System.out.println(f);
        }

        // 移动并重命名文件
        file.renameTo(new File("D:\\aa\\meinv.jpg"));

        // 设置修改时间
        // 参数就是计算机元年到某个时间的毫秒值
        file.setLastModified(1000L);
        // 设置只读文件
        file.setReadOnly();
    }
}

四、分隔符

separatorChar         目录分隔符          在windows中是\             在linux中是 /

 
pathSeparatorChar  路径分隔符          在windows中是 ;            在linux中 是 :

五、File类操作文件与递归(重要)

(一)创建文件

public class TestDemo1 {
    public static void main(String[] args) throws IOException {
        File file = new File("chapter16\\aaa");

        // mkdirs()方法无论文件夹在不在，都会创建成功
        file.mkdirs();
        File file1 = new File(file + File.separator + "a.txt");

        // createNewFile()方法如果文件已存在是false
        boolean newFile = file1.createNewFile();
        if (newFile) {
            System.out.println("创建成功");
        } else {
            System.out.println("创建失败");
        }
    }
}

(二)单个文件夹查找文件

        需求：定义一个方法，查找某一个文件夹中，是否有以.avi结尾的文件，暂时不需要考虑子文件夹。

public class TestDemo2 {
    public static void main(String[] args) {
        boolean b = haveAVI(new File("D:\\test"));
        System.out.println(b);
        // D:\test\a - 副本.avi
        // true
    }

    private static boolean haveAVI(File src) {
        File[] files = src.listFiles();
        for (File f : files) {
            if (f.isFile() && f.getName().endsWith(".avi")) {
                System.out.println(f);
                return true;
            }
        }
        return false;
    }
}

(三)递归遍历硬盘查找文件

凡是考虑到文件夹里面的递归操作，可套用下面的步骤：

  1. 进入文件夹src

  2. 遍历数组，依次得到src里面的每一个文件或文件夹

  3. 判断：如果是文件，就可以执行题目的业务逻辑

  4. 判断：如果是文件夹，就可以递归      （细节：再次调用本方法的时候，参数一定要是src的次一级路径）

public class TestDemo3 {
    public static void main(String[] args) {
        // 查找电脑中所有以.avi结尾的文件
        findAvi();
    }

    private static void findAvi() {
        File[] files = File.listRoots();
        for (File file : files) {
            findAvi(file);
        }
    }

    private static void findAvi(File src) {
        // 1.进入文件夹src
        File[] files = src.listFiles();
        // 2.遍历数组，依次得到src里面的每一个文件或文件夹
        if (files != null) {
            for (File file : files) {
                if (file.isFile()){
                    // 3.判断：如果是文件，就可以执行题目的业务逻辑
                    String name = file.getName();
                    if (name.endsWith(".avi")){
                        System.out.println(name);
                    }
                  //  4.判断：如果是文件夹，就可以递归
                  //  （细节：再次调用本方法的时候，参数一定要是src的次一级路径）
                }else {
                    findAvi(file);
                }
            }
        }
    }
}

运行结果：

(四)递归删除文件夹

递归删除ggg文件夹

删除一个多级文件夹
如果我们要删除一个有内容的文件夹：1.先删除文件夹里面所有的内容；2.再删除自己

public class TestDemo4 {
    public static void main(String[] args) {
        // 删除一个多级文件夹
        delete(new File("D:\\test\\ggg"));
    }

    // 方式一：
    private static void delete(File src) {
        // 进入src
        File[] files = src.listFiles();
        // 如果执行过程中遇到了空指针异常，可以对files做非空判断
        if (files != null) {
            // 遍历数组
            for (File file : files) {
                if (file.isFile()) {
                    // 判断，如果是文件，就删除
                    file.delete();
                } else {
                    // 判断，如果是文件夹，就递归
                    // 这里的参数一定是src的次一级路径
                    delete(file);
                }
            }
            // 最后删除自己
            src.delete();
        }
    }

    // 方式二：
    public static void del(File file){
        // 如果是目录
        if (file.isDirectory()){
            // 获取所有的子目录和子文件
            File[] files = file.listFiles();
            for (File f : files) {
                del(f);
            }
        }
        // 删除文件或者目录
        file.delete();
    }
}

ggg文件夹被成功删除！ 

(五)统计文件夹总大小

public class TestDemo5 {
    public static void main(String[] args) {
        long len = getLen(new File("D:\\test")) / 1024;
        System.out.println(len + "KB");
        // 178KB
    }

    private static long getLen(File src) {
        // 1.定义变量进行累加
        long len = 0;
        // 2.进入src文件夹
        File[] files = src.listFiles();
        // 3.遍历数组
        if (files != null) {
            for (File file : files) {
                // 4.判断是不是文件
                if (file.isFile()) {
                    // 5.是文件，则进行长度累加
                    len += file.length();
                } else {
                    // 6.不是文件，则继续遍历
                    len += getLen(file);
                }
            }
        }
        // 7.返回最后累加的长度
        return len;
    }
}

(六)统计各种文件数量(重要)

需求：统计一个文件夹中每种文件的个数并打印。（考虑子文件夹）
打印格式如下：
txt:3个
doc:4个
jpg:6个

参数：
      要统计的那个文件夹
返回值：
      用来统计map集合
      键：后缀名 值：次数

      a.txt
      a.a.txt
      aaa（不需要统计的）

遍历方式一：

public class Test6 {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\test");
        HashMap<String, Integer> hm = getCount(file);
        System.out.println(hm);
        // {jpg=6, txt=3, avi=3, doc=4}
    }

    public static HashMap<String, Integer> getCount(File src) {
        // 1.定义集合用来统计
        HashMap<String, Integer> hm = new HashMap<>();
        // 2.进入src文件夹
        File[] files = src.listFiles();
        // 3.遍历数组
        for (File file : files) {
            // 4.判断，如果是文件，统计
            if (file.isFile()) {
                // a.txt
                String name = file.getName();
                String[] arr = name.split("\\.");
                if (arr.length >= 2) {
                    String endName = arr[arr.length - 1];
                    if (hm.containsKey(endName)) {
                        // 存在
                        int count = hm.get(endName);
                        count++;
                        hm.put(endName, count);
                    } else {
                        // 不存在，没有后缀名的文件，分割后长度为1
                        hm.put(endName, 1);
                    }
                }
            } else {
                // 5.判断，如果是文件夹，递归
                // sonMap里面是子文件中每一种文件的个数
                HashMap<String, Integer> sonMap = getCount(file);
                // hm:  txt=1  jpg=2  doc=3
                // sonMap: txt=3 jpg=1
                // 遍历sonMap把里面的值累加到hm当中
                Set<Map.Entry<String, Integer>> entries = sonMap.entrySet();
                for (Map.Entry<String, Integer> entry : entries) {
                    String key = entry.getKey();
                    int value = entry.getValue();
                    if (hm.containsKey(key)) {
                        // 存在
                        int count = hm.get(key);
                        count = count + value;
                        hm.put(key, count);
                    } else {
                        // 不存在
                        hm.put(key, value);
                    }
                }
            }
        }
        return hm;
    }
}

遍历方式二：

public class TestDemo6 {
    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = getCount(new File("D:\\test"));
        System.out.println(hashMap);
        // {jpg=6, txt=3, avi=3, doc=4}
    }

    private static HashMap<String, Integer> getCount(File src) {
        File[] files = src.listFiles();
        HashMap<String, Integer> hm = new HashMap<>();
        for (File file : files) {
            if (file.isFile()) {
                String name = file.getName();
                String[] split = name.split("\\.");
                // 分成2个才考虑
                if (split.length >= 2) {
                    String endName = split[split.length - 1];
                    if (hm.containsKey(endName)) {
                        // 存在
                        int count = hm.get(endName);
                        count++;
                        hm.put(endName, count);
                    } else {
                        // 不存在
                        hm.put(endName, 1);
                    }
                }
            } else {
                HashMap<String, Integer> sonMap = getCount(file);
                Set<String> keySet = sonMap.keySet();
                for (String key : keySet) {
                    int value = sonMap.get(key);
                    if (hm.containsKey(key)) {
                        // 存在
                        int count = hm.get(key);
                        count = count + value;
                        hm.put(key, count);
                    } else {
                        // 不存在
                        hm.put(key, value);
                    }
                }
            }
        }
        return hm;
    }
}

(七)统计指定文件的个数

public class FileTest {
    public static void main(String[] args) {
        getCount(new File("G:\\develop\\workspace"));
        System.out.println("java文件" + javaCount);
        System.out.println("class文件" + classCount);     
    }

    static int javaCount = 0;
    static int classCount = 0;

    // 统计文件个数:java文件与class文件个数
    public static void getCount(File file) {
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File file1 : files) {
                getCount(file1);
            }
        } else if (file.getName().endsWith(".java")) {
            javaCount++;
        } else if (file.getName().endsWith(".class")) {
            classCount++;
        }
    }
}
File详解——文件递归遍历所有
虚空掠夺者~
08-25 739
IO流：本质是一套用于数据传输的机制， .\d.—>匹配是否有数字 - 文件的传输以内存为参照物-->内存 - 输入流：往内存中传输数据 - 输出流：从内存往外传输到介质中（可存储的介质，硬盘，光盘等） File类代表文件或者文件夹的类，用于java操作文件系统的类 - 文件的创建——boolean createNewFile() 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。 - File类的构造方法中，创建文件对象----
采用递归查询文件
09-25
采用递归查询文件的例子,可以查询指定目录下的符合条件的文件，可以搜索文件中的字符串
File类、递归
qq_34272315的博客
09-09 238
day08【File类、递归】 主要内容 File类 递归 教学目标 能够说出File对象的创建方式 能够说出File类获取名称的方法名称 能够说出File类获取绝对路径的方法名称 能够说出File类获取文件大小的方法名称 能够说出File类判断是否是文件的方法名称 能够说出File类判断是否是文件夹的方法名称 ...
文件检索递归案例（JAVA）
最新发布
zzb1580的博客
11-05 288
本方法使用递归实现了目标文件的检索，是学习递归入门非常好的一个案例。
JAVA 文件递归查询
u014369382的专栏
05-20 824
import java.io.File;  import java.util.ArrayList;  import java.util.List;  import java.util.Queue;    /**  * @author tiwson 2014-05-20  *   */  public class FileSearcher {       
java 递归搜索文件_Java如何递归搜索文件？
weixin_32349913的博客
02-25 218
本示例演示了如何使用FileUtils类listFiles()方法搜索由其扩展名指定的文件。我们还可以定义以递归方式找到子目录中的文件。packageorg.nhooo.example.commons.io;importorg.apache.commons.io.FileUtils;importjava.io.File;importjava.util.Collection;publicc...
基于Java的文件递归查询
java小新
05-13 391
基于Java的文件递归查询 思路:首先创建一个递归方法,该方法需要先把指定目录下的文件转换为 File[] 集合,然后对该集合进行遍历并判断.如果被遍历对象还是目录,就对该对象再次调用该遍历方法.但是,如果判断该对象是文件的话,就把该对象输出. 上代码: import java.io.File; public class Demo03DiGuiFiles { public static void main(String[] args) { //首先,确定
JavaSE File类详解：操作文件与目录的基础方法
Java SE中的`java.io.File`类是核心的基础类，它代表了操作系统中的一个文件或目录，提供了一系列方法来操作文件和目录。以下是关于`File`类的一些关键知识点： 1. 构造方法： - `File(String pathname)`：根据...
JavaSE核心面试题详解与教程
在Java中，可以通过File类和递归算法来遍历目录，输出一个目录及其所有子目录下的文件列表。递归方法在处理文件系统这种树状结构时非常有效。 2. 泛型中extends和super的区别 在Java泛型中，extends关键字用来...
JavaSE笔试程序题（20180307）
06-13
20. **扫描文件**：使用File类和FileInputStream，遍历目录及子目录。 21. **分数计算**：浮点数除法，考虑保留精度。 22. **关键字计数**：逐行读取文件，使用HashMap存储关键字计数。 23. **列出文件名**：使用...
java 递归搜索文件_java – 递归搜索自己的文件系统
weixin_31289735的博客
02-25 157
我正在尝试搜索FSElement,它可以是文件或目录,在根目录为localroot目录的文件结构中查找,然后继续尝试查找,但它不会返回我预期的结果.任何人都可以建议我在哪里错了.private FSElement getTargetFromName(String targetName) throws CommandNotExecutedException {fsElement = localroo...
递归 查找 一个文件夹所有的子文件夹和文件
哈哈__哈哈的专栏
12-23 147
[code="java"]import java.io.*; public class RecursionTest{ public static void main(String[] args){ String fullFileName = "c:/A"; File f = new File(fullFileName); p(f.getName()); int ...
文件的递归搜索(Java版)
qq_46653910的博客
12-26 674
文件递归搜索大致可以分为以下几步：确定递归出口，当搜索的文件是null，那就直接返回，退出递归搜索。如果当前是一个文件，搜索完成，现在可以对该文件进行相应的处理。如果当前是一个文件夹，那就依次搜索该文件夹中的子文件夹。
递归查找文件夹与所有文件-java基础
normol的博客
09-06 454
《Thinking in java》中例子的简化版package java1.myFile;import java.io.File; import java.io.FilenameFilter; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.regex.Pa
Java递归运用：搜索文件程序
qq_51438138的博客
03-22 664
package File_io.digui; import java.io.File; public class Demon { public static void main(String[] args) { //运用递归知识设计一个搜索文件的方法 searchFile(new File("C:/"),"绘图2.pdf");//传入目录和文件夹 } public static void searchFile(File dir,String f.
复习JavaFile类_递归_综合案例
菜鸡逆袭的博客
10-04 255
复习File类_递归 主要内容 File类 递归 第一章 File类 1.1 概述 java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作, 这里需要注意一点File不能用于对文件内容进行操作, 对文件内容进行操作需要使用FileInputStream与FileOutputStream。 1.2 构造方法 注: 构造File对象的时候要注意传入的参...
递归查找文件
12-31 265
static QStringList FindFilesEx(const QString& strFullName, bool bRecursion = true) { QStringList tmpFiles; QString strPath; QStringList strFilters; if(!ParsePath(strFullName, strPath, strFilters)) { .
java实现递归查找文件
10-18 787
用java递归查找文件import java.io.*;class FileFind{ static void getDir(String strPath) throws Exception {  try  {   File f=new File(strPath);   if(f.isDirectory())   {    File[] fList=f.listFiles();    for(
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值