File

• file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径

• 这个路径可以是存在的，也可以是不存在的

• 绝对路径与相对路径
  绝对路径是带盘符的。
  相对路径是不带盘符的，默认到当前项目去找
  

import java.io.File;
public class FileDemo1 {
    public static void main(String[] args) {
        //1、根据字符串表示的路径，变成File对象
        String str = "C:\\User\\alienware\\Desktop\\a.txt";
        File f1 = new File(str);
        System.out.println(f1);//C:\User\alienware\Desktop\a.txt
        //2、父级路径：
        //子级路径
        String parent = "C:\\User\\alienware\\Desktop";
        String child = "a.txt";
        File f2 = new File(parent,child);
        System.out.println(f2);//C:\User\alienware\Desktop\a.txt
        //3、把一个File表示的路径和String表示路径进行拼接
        File parent2 = new File("C:\\User\\alienware\\Desktop");
        String child2 = "a.txt";
        File f3 = new File(parent2,child2);
        System.out.println(f3);//C:\User\alienware\Desktop\a.txt
    }
}

File常见的成员方法

• 获取判断：
  

import java.io.File;
public class FileDemo2 {
    public static void main(String[] args) {
        //1、对一个文件的路径进行判断
        File f1 = new File("D:\\Test2\\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:\\Test2\\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:\\Test2\\c.txt");
        System.out.println(f3.isDirectory());//false
        System.out.println(f3.isFile());//false
        System.out.println(f3.exists());//false
    }
}

import java.io.File;
public class FileDemo3 {
    public static void main(String[] args) {
        //1、length 返回文件的大小(字节数量)
        //细节1：这个方法只能获取文件的大小，单位是字节
        //如果单位我们要是M,G，可以不断的除以1024
        //细节2：这个方法无法获取文件夹的大小
        //如果我们要获取一个文件夹的大小，需要把这个文件夹里面所有的文件大小都累加在一起。
        File f1 = new File("D:\\Test2\\a.txt");
        long length = f1.length();
        System.out.println(length);//3

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

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

        File f4 = new File("untitled4\\a.txt");
        String path2 = f4.getAbsolutePath();
        System.out.println(path2);
        System.out.println("----------");

        //3、getPath 返回定义文件时使用的路径
        File f5 = new File("D:\\Test2\\a.txt");
        String path3 = f5.getPath();
        System.out.println(path3);//D:\Test2\a.txt

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

        //4、getName 获取名字
        //细节1：
        // a.txt:
        //a 文件名
        //txt 后缀名、扩展名
        //细节2：
        //文件夹：返回的就是文件夹的名字
        File f7 = new File("D:\\Test2\\a.txt");
        String path5 = f7.getName();
        System.out.println(path5);//a.txt

        File f8 = new File("D:\\Test2\\bbb");
        String path6 = f8.getName();
        System.out.println(path6);//bbb
        System.out.println("----------");

        //lastModified
        File f9 = new File("D:\\Test2\\a.txt");
        long time = f9.lastModified();
        System.out.println(time);//1673703497849
    }
}

• 创建、删除
  

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

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

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

        //4、delete() 删除文件、空文件夹
        /*
        细节：
        如果删除的是文件，则直接删除，不走回收站。
        如果删除的是空文件夹，则直接删除，不走回收站
        如果删除的是有内容的文件夹，则删除失败
         */
        File f4 = new File("D:\\Test2\\a.txt");
        boolean delete = f4.delete();
        System.out.println(delete);//true
    }
}

获取并遍历

注意：
1、当调用者file表示的路径不存在时，返回null
2、当调用者file表示的路径是文件时，返回null
3、当调用者file表示的路径是一个空文件夹时，返回一个长度为0的数组
4、当调用者file表示的路径是一个有内容的文件夹时，将里面所有的文件和文件夹的路径放在File数组中返回
5、当调用者file表示的路径是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
6、当调用者file表示的路径是需要权限才能访问的文件夹时，返回null

import java.io.File;
public class FileDemo5 {
    public static void main(String[] args) {
        //1、创建File对象
        File f1 = new File("D:\\Test2");
        //2、listFile方法
        //作用：获取Test2文件夹里面的所有内容，把所有的内容放到数组返回
        File[] files = f1.listFiles();
        for (File file : files) {
            //file依次表示Test2文件夹里面的每一个文件或者文件夹
            System.out.println(file);
        }
    }
}

import java.io.File;
import java.io.FilenameFilter;
import java.util.Arrays;
public class FileDemo6 {
    public static void main(String[] args) {
        //1、listRoots 获取系统中所有的盘符
        File[] arr = File.listRoots();
        System.out.println(Arrays.toString(arr));

        //2、list() 获取当前该路径下所有的内容(仅仅能获取名字)
        File f1 = new File("D:\\Test2");
        String[] arr2 = f1.list();
        for (String s : arr2) {
            System.out.println(s);
        }

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

import java.io.File;
import java.io.FilenameFilter;
import java.util.Arrays;
public class FileDemo7 {
    public static void main(String[] args) {
        //1、创建File对象(重点)
        File f1 = new File("D:\\Test2");
        //调用listFiles
        File[] arr1 = f1.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return true;
            }
        });
        System.out.println(Arrays.toString(arr1));
    }
}

综合练习

1、需求：在当期模块的aaa文件夹中创建一个a.txt文件

import java.io.File;
import java.io.IOException;
public class Test1 {
    public static void main(String[] args) throws IOException {
        //1、创建a.txt的父级路径
        File file = new File("untitled4\\aaa");
        //2、创建父级路径
        //如果aaa存在，那么创建失败,否则创建成功
        file.mkdirs();
        //3、拼接父级路径和子级路径
        File src = new File(file,"a.txt");
        boolean newFile = src.createNewFile();
        if(newFile){
            System.out.println("创建成功");
        }else {
            System.out.println("创建失败");
        }
    }
}

2、需求：定义一个方法找到某一个文件夹中，是否有以avi结尾的电影（暂时不需要考虑子文件夹）

import java.io.File;
public class Test2 {
    public static void main(String[] args) {
        File file = new File("D:\\Test2");
        boolean b = havaAVI(file);
        System.out.println(b);
    }
    /*
    作用：用来找某一个文件夹中，是否有以avi结尾的电影
    形参：要查找的文件夹
    返回值：查找的结果 存在true 不存在false
     */
    public static boolean havaAVI(File file){
        //1、进入Test2文件夹，而且要获取里面所有的内容
        File[] files = file.listFiles();
        //2、遍历数组获取里面每一个元素
        for (File f : files) {
            //f:依次表示aaa文件夹里面每一个文件或者文件夹的路径
            if(f.isFile() && f.getName().endsWith(".avi")){
                return true;
            }
        }
        return false;
    }
}

3、需求：找到电脑中所有以avi结尾的电影（需要考虑子文件夹）

import java.io.File;
public class Test3 {
    public static void main(String[] args) {
        findAVI();
    }

    public static void findAVI(){
        //获取本地所有盘符
        File[] arr = File.listRoots();
        for (File file : arr) {
            findAVI(file);
        }
    }
    //使用递归
    public 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(file);
                    }
                } else {
                    //4、判断，如果是文件夹，就可以递归
                    //细节：再次调用本方法时，参数一定要是src的次一级路径
                    findAVI(file);
                }
            }
        }
    }
}

4、删除一个多级文件夹

import java.io.File;
public class Test4 {
    public static void main(String[] args) {
        //删除一个多级文件夹
        //1、先删除文件夹里面一个有内容的文件夹
        //2、再删除自己
        File file = new File("D:\\Test2\\aaa");
        delete(file);
    }

    //作用：删除src文件夹
    //参数：要删除的文件夹
    public static void delete(File src){
        //1、先删除文件夹里面所有的内容
        //进入src
        File[] files = src.listFiles();
        //遍历
        for (File f : files) {
            //如果是文件就删除
            if(f.isFile()){
                f.delete();
            }else {
                //如果是文件夹，就递归
                delete(f);
            }
        }
        //2、再删除自己
        src.delete();
    }
}

5、统计一个文件夹的总大小

import java.io.File;
public class Test5 {
    public static void main(String[] args) {
        File file = new File("D:\\Test2\\ccc");
        long getlen = getlen(file);
        System.out.println(getlen);
    }
    //作用：统计一个总文件夹的大小
    //参数：要统计的那个文件夹
    //返回值：统计之后的结果
    public static long getlen(File src) {
        //1、定义变量进行累加
        long len = 0;
        //2、进入src文件夹
            File[] files = src.listFiles();
            //3、遍历数组
            for (File f : files) {
                //4、判断
                if (f.isFile()) {
                    len = len + f.length();
                } else {
                    //判断，如果是文件夹就递归
                    len = len + getlen(f);
                }
            }
            return len;
    }
}

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

import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test6 {
    public static void main(String[] args) {
        File file = new File("D:\\Test");
        HashMap<String,Integer> hm = getCount(file);

        System.out.println(hm);
    }
    /*
    作用：统计一个文件夹中每种文件的个数
    参数：要统计的那个文件夹
    返回值：用来统计map集合
    键：后缀名 值：次数
     */
    public static HashMap<String,Integer> getCount(File src){
        //1、定义集合来统计
        HashMap<String,Integer> hm = new HashMap<>();
        //2、进入src文件夹
        File[] files = src.listFiles();
        if(files != null) {//判断非空，防止空指针异常
            //3、遍历数组
            for (File f : files) {
                //4、判断，如果是文件，统计
                if (f.isFile()) {
                    String name = f.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++;
                        } else {
                            //不存在
                            hm.put(endName, 1);
                        }
                    }
                }
                //5、判断，如果是文件夹，递归
                //sonMap里面是子文件中的每一种文件的个数
                HashMap<String, Integer> sonMap = getCount(f);
                //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;
    }
}