Java File类及案例

File概述和构造方法

• File对象就表示一个路径，可以是文件路径、也可以是文件夹的路径
• 这个路径可以是存在的，也允许是不存在的

方法名称	说明
public File (String pathname)	把字符串表示的路径变成File对象
public File (Srting parent, String child)	把父级路径和子级路径进行拼接
public File (File parent, String child)	把父级对象和子级路径进行拼接

File成员方法

判断、获取

创建、删除

获取并遍历（蓝色方法重要掌握）

案例示例

案例一：

在当前模块下的aaa文件夹中创建一个a.txt文件

package com.liming.file01;

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

public class Demo02 {
    public static void main(String[] args) throws IOException {
        /* 在当前模块下的aaa文件夹中创建一个a.txt文件 */

        //1.创建父级路径aaa
        File file = new File("day10\\aaa");
        file.mkdirs();//aaa不存在才创建，存在就创建失败
        //2.拼接父级路径和子级路径
        File src = new File(file, "a.txt");
        boolean b = src.createNewFile();
        if (b) {
            System.out.println("创建成功");
        } else {
            System.out.println("创建失败");
        }
    }
}

案例二：

找某一个文件夹中是否有以avi结尾的电影 (不考虑子文件夹)

package com.liming.file01;

import java.io.File;

public class Demo03 {
    public static void main(String[] args) {
        /* 找某一个文件夹中是否有以avi结尾的电影 暂时不考虑子文件夹*/
        File file = new File("D:\\JavaSE305\\day10\\aaa");
        boolean b = findAVI(file);
        System.out.println(b);
    }

    public static boolean findAVI(File file) {
        File[] files = file.listFiles();
        for (File f : files) {
            if (f.isFile() && f.getName().endsWith(".avi")) {
                return true;
            }
        }
        return false;
    }
}

案例三：

遍历硬盘查找以avi结尾的文件 需要考虑子文件夹

package com.liming.file01;

import java.io.File;

public class Demo04 {
    public static void main(String[] args) {
        /* 遍历硬盘查找以avi结尾的文件 需要考虑子文件夹 */
       findAVI();
    }

    /**
     * 获取磁盘所有盘符
     */
    public static void findAVI(){
        File[] files = File.listRoots();
        for (File src : files) {
            findAVI(src);
        }
    }

    public static void findAVI(File src) {
        //1. 获取c盘目录下所有文件和文件夹
        File[] files = src.listFiles();
        //5. 处理盘符权限问题
        if (files != null) {
            //2. 遍历获取到的文件夹和文件
            for (File file : files) {
                if (file.isFile()) {
                    //3.判断，如果是文件可以执行题目的业务逻辑
                    String name = file.getName();
                    if (name.endsWith(".avi")) {
                        System.out.println(file);
                    }
                } else {
                    //4. 判断如果是文件夹，使用递归继续遍历判断文件夹里面的内容
                    findAVI(file);
                }
            }
        }
    }
}

案例四：

/* 删除一个多级文件夹
* 思路：递归
* 1.先删除文件夹里面的所有内容
* 2.在删除自己
* */

package com.liming.file01;

import java.io.File;

public class Demo05 {
    public static void main(String[] args) {
        /* 删除一个多级文件夹
         * 思路：递归
         * 1.先删除文件夹里面的所有内容
         * 2.在删除自己
         *  */
        File file = new File("day10\\aaa");
        deleteFile(file);
    }

    /**
     * @param file 要删除的文件夹
     */
    public static void deleteFile(File file) {
        //1. 先删除文件夹里面所有内容
        //1.1 获取文件夹中所有内容
        File[] files = file.listFiles();
        //1.2 遍历获取到的数组
        for (File f : files) {
            if (f.isFile()) {
                //1.3 判断如果是文件直接删除
                f.delete();
            } else {
                //1.4 如果是文件夹就递归
                deleteFile(f);
            }
        }
        //2. 在删除自己
        file.delete();
    }
}

案例五：

统计一个文件夹的总大小

package com.liming.file01;

import java.io.File;

public class Demo06 {
    public static void main(String[] args) {
        /* 统计一个文件夹的总大小 */
        File src = new File("D:\\aaa\\bbb");
        long len = getLen(src);
        System.out.println(len);
    }

    /**
     *
     * @param src 要统计的那个文件夹
     * @return 返回统计后的文件夹大小，单位字节
     */
    public static long getLen(File src) {
        //1. 定义变量进行累加
        long len = 0;
        //2. 获取src里面所有文件和文件夹
        File[] files = src.listFiles();
        //3. 遍历文件夹数组
        for (File file : files) {
            if (file.isFile()) {
                //4. 判断
                len = len + file.length();
            } else {
                //5. 如果是文件夹使用递归继续求大小
                len = len + getLen(file);
            }
        }
        return len;
    }
}

案例六：

/* 统计一个文件夹中每种文件的个数并打印(考虑子文件夹)
* 打印格式如下：
* txt:x个
* doc:x个
* jpg:x个
* */

package com.liming.file01;

import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo07 {
    public static void main(String[] args) {
        /* 统计一个文件夹中每种文件的个数并打印(考虑子文件夹)
         * 打印格式如下：
         * txt:x个
         * doc:x个
         * jpg:x个
         * */
        File file = new File("D:\\aaa\\bbb");
        Map<String, Integer> map = getCount(file);
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + ":" + value + "个");
        }
    }

    /**
     * 文件可能出现类型：
     * a.txt\a.a.txt\aaa(不需要统计)
     *
     * @param src
     */
    public static Map<String, Integer> getCount(File src) {
        //1. 定义Map集合用来统计,键:后缀名 值:出现次数
        Map<String, Integer> map = new HashMap<>();
        //2. 获取src目录下所有文件夹和文件
        File[] files = src.listFiles();
        //3. 遍历获取到的数组
        for (File file : files) {
            //4. 判断，如果是文件就统计
            if (file.isFile()) {
                //a.a.txt
                String name = file.getName();
                String[] arr = name.split("\\.");
                if (arr.length >= 2) {
                    String endName = arr[arr.length - 1];
                    if (map.containsKey(endName)) {
                        //获取键出现的次数
                        int count = map.get(endName);
                        count++;
                        map.put(endName, count);
                    } else {
                        //键没出现过
                        map.put(endName, 1);
                    }
                }
            } else {
                //5. 如果是文件夹，递归
                //sonMap里面存放着子文件中每一种文件的数量
                Map<String, Integer> sonMap = getCount(file);
                //遍历sonMap把里面的数据累加到map集合中去
                Set<Map.Entry<String, Integer>> entries = sonMap.entrySet();
                for (Map.Entry<String, Integer> entry : entries) {
                    String key = entry.getKey();
                    int value = entry.getValue();
                    if (map.containsKey(key)) {
                        //存在
                        int count = map.get(key);
                        count = count + value;
                        map.put(key, count);
                    } else {
                        //不存在
                        map.put(key, value);
                    }
                }
            }
        }
        return map;
    }
}

总结

解题思路：
如果涉及子文件问题和多级路径可以考虑使用递归一级一级解决
1.获取src路径下的所有文件和文件夹，存放在数组
2.遍历获取到的数组
3.判断，如果是文件直接执行题目需求
4.判断，如果是文件夹进行递归