Java:File类

目录

File类

1、File的常见成员方法(判断、获取)

2、File类，创建和删除

3、File类 获取并遍历

---

File类

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

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

常见构造方法

示例：

  //根据字符串表示的路径，变成File对象
        String str = "C:\\Users\\15562\\Desktop\\a.txt";
        File file1 = new File(str);
        System.out.println(file1);
 
        //父级路径：C:\Users\15562\Desktop
        //子级路径：a.txt
        String parent1 = "C:\\Users\\15562\\Desktop";
        String child = "a.txt";
        File file2 = new File(parent1,child);
        System.out.println(file2);
        File file3 = new File(parent1 + "\\" + child);
        System.out.println(file3);
        //把一个File表示的路径和String表示的路径进行拼接
        File parent2 = new File("C:\\Users\\15562\\Desktop");
        String child2 = "a.txt";
        File file4 = new File(parent2,child2);
        System.out.println(file4);

绝对路径和相对路径是什么意思?

绝对路径是带盘符的。

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

1、File的常见成员方法(判断、获取)

  isDirectory()， isFile()，exists()

        //对一个文件的路径进行判断
        File file = new File("D:\\aaa\\a.txt");
        //判断此路径名表示的File是否为文件夹
        System.out.println(file.isDirectory());//false
        //判断此路径名表示的File是否为文件
        System.out.println(file.isFile());//ture
        //判断此路径名表示的File是否存在
        System.out.println(file.exists());//ture
        System.out.println("----------------------");
 
        //对一个文件夹的路径进行判断
        File file1 = new File("D:\\aaa\\bbb");
        //判断此路径名表示的File是否为文件夹
        System.out.println(file1.isDirectory());//ture
        //判断此路径名表示的File是否为文件
        System.out.println(file1.isFile());//false
        //判断此路径名表示的File是否存在
        System.out.println(file1.exists());//ture
        System.out.println("-----------------");
        //对不存在的一个文件的路径进行判断
        File file2 = new File("D:\\aaa\\b.txt");
        //判断此路径名表示的File是否为文件夹
        System.out.println(file2.isDirectory());//false
        //判断此路径名表示的File是否为文件
        System.out.println(file2.isFile());//false
        //判断此路径名表示的File是否存在
        System.out.println(file2.exists());//false

length()，getAbsolutePath()，getPath()，getName()

        //1.length返回文件的大小(字节数量>
        //细节1:这个方法只能获取文件的大小，单位是字节
        //如果单位我们要是M，G，可以不断的除以1024
        //细节2:这个方法无法获取文件夹的大小
        //如果我们要获取一个文件夹的大小，需要把这个文件夹里面所有的文件大小都累加在一起。
        File file = new File("D:\\aaa\\a.txt");
        long len = file.length();
        System.out.println(len);//0
        //返回文件绝对路径
        String path1 = file.getAbsolutePath();
        System.out.println(path1);//\aaa\a.txt
        //返回定义文件时使用的路径
        String path2 = file.getPath();
        System.out.println(path2);//\aaa\a.txt
        //获取文件名
        //文件夹：就是文件夹的名字
        String name1 = file.getName();
        System.out.println(name1);//a.txt

2、File类，创建和删除

 createNewFile()，mkdir()，mkdirs()，delete()

      //1.createNewFile 创建一个新的空的文件
        //细节1: 如果当前路径表示的文件是不存在的，则创建成功，方法返回true
        //  如果当前路径表示的文件是存在的，则创建失败，方法返回false
        // 细节2:如果父级路径是不存在的，那么方法会有异常IOException
        //细节3: createNewFile方法创建的一定是文件，如果路径中不包含后缀名，则创建一个没有后缀的文件
        File f1 = new File( "D:\\aaa\\ddd" );
        boolean b1 = f1.createNewFile();
        System.out.println(b1); //true
        // 2.mkdir make Directory，文件夹（目录>
        //细节1: windows当中路径是唯一的，如果当前路径已经存在，则创建失败，返回false
        // 细节2: mkdir方法只能创建单级文件夹，无法创建多级文件夹。
        File f2 = new File("D:\\aaa\\aaa\\bbb\\ccc " );
        boolean b2 = f2.mkdir();
        System.out.println(b2);//false
        // 3.mkdirs创建多级文件夹
        //细节:既可以创建单级的，又可以创建多级的文件夹
        File f3 = new File(  "D:\\aaa\\ggg" );
        boolean b3 = f3.mkdirs();
        System.out.println(b3); //true
        //删除文件或空文件夹
        boolean delete = f3.delete();
        System.out.println(delete);//true

3、File类 获取并遍历

        //创建File对象
        File f1 = new File( "D:\\aaa" );
        //listFiles方法
        //作用:获取aaa文件夹里面的所有内容，把所有的内容放到数组中返回
        File[] files = f1.listFiles();
        for (File file : files) {
            //file依次表示aaa文件夹里面的每一个文件或者文件夹
            System.out.println(file);
        }

 注意：

1、当调用者File表示的路径不存在时，返回null

2、当调用者File表示的路径是文件时，返回null

3、当调用者File表示的路径是一个空文件夹时，返回一个长度为0的数组

4、当调用者File表示的路径是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回

5、当调用者File表示的路径是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在

File数组中返回，包含隐藏文件

6、当调用者File表示的路径是需要权限才能访问的文件夹时，返回null

 listRoots()， list() ，list(FilenameFilter filter)

        //1.liStRoots获取系统中所有的盘符
        File[]arr = File.listRoots();
        System.out.println(Arrays.toString(arr));
        //2.list()获取当前该路径下所有内容(仅仅能获取名字)
        File f1 = new File("D:\\aaa");
        String[] arr2 = f1.list();
        for (String s : arr2)
        System.out.println(s);
        //3.list(FilenameFilter filter)利用文件名过滤器获取当前该路径下所有内容
        //需求:现在要获取D:\\aaa文件夹里面所有的txt文件
        File f2 = new File("D:\\aaa");
        //accept方法的形参，依次表示aaa文件夹里面每一个文件或者文件夹的路径
        //参数一:父级路径
        //参数二:子级路径
        //返回值:如果返回值为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));

 listFiles()， listFiles(FileFilter filter)，listFiles(FilenameFilter filter)

        //1.创建File对象
        File f = new File( "D:\\aaa");
        //2.需求:打印里面所有的txt文件
        File[] arr = f.listFiles();
        for (File file : arr){
            //file依次表示aaa文件夹里面每一个文件或者文件夹的路径
            if(file.isFile() && file.getName().endsWith(".txt")){
                System.out.println(file);
            }
        }
 
        //调用listFiles(FileFilter filter)
        File[] arr1 = f.listFiles(new FileFilter() {
             @Override
             public boolean accept(File pathname) {
                 return pathname.isFile() && pathname.getName().endsWith(".txt");
                }
             });
        System.out.println(Arrays.toString(arr1)) ;
        //调用listFiles(FilenameFilter filter)
        File[] arr2 = f.listFiles(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(arr2)) ;

 单个文件夹找文件

//1.创建File对象,战时不考虑子文件夹
        File f = new File( "D:\\aaa");
        //遍历数组
        File[] arr = f.listFiles();
        for (File file : arr){
            //file依次表示aaa文件夹里面每一个文件或者文件夹的路径
            if(file.isFile() && file.getName().endsWith(".txt")){
                System.out.println(file);
            }
        }

遍历硬盘查找文件

@Test
    public void test() throws IOException {
        findTxt();
    }
    //获取系统所有盘符
    public static void findTxt(){
        File[] arr = File.listRoots();
        for (File file : arr) {
            findTxt(file);
        }
    }
    //找txt文件
    public static void findTxt(File file){
        File[] files = file.listFiles();
        //遍历数组，依次得到每一个文件或文件夹
        if (files != null){
            for (File file1 : files) {
                //判断是否是文件
                if (file1.isFile()){
                    String name = file.getName();
                    if (name.endsWith(".txt")){
                        System.out.println(name);
                    }
                }else {
                    //如果是文件夹，就使用递归
                    findTxt(file);
                }
            }
        }
    }

删除文件夹（包括里面的文件）

 public void test() throws IOException {
        File file = new File("D:\\aaa");
        delete(file);
    }
    //删除aaa文件夹
    //file要删除的文件
    public static void delete(File file){
        File[] files = file.listFiles();
        //遍历
        for (File file1 : files) {
            //判断，如果是文件删除
            if (file1.isFile()){
                file1.delete();
            }else {
                //是文件夹就递归
                delete(file1);
            }
        }
        //最后在删除自己
        file.delete();
    }

统计文件夹大小

public void test() throws IOException {
        File file = new File("D:\\aaa");
        long len = getLen(file);
        System.out.println(len);
    }
    //统计文件夹大小
    public static long getLen(File file){
        //定义变量进行累加
        long len = 0;
        File[] files = file.listFiles();
        //遍历数组
        for (File file1 : files) {
            //判断是否位文件
            if (file1.isFile()){
                //文件大小进行累加
                len = len + file1.length();
            }else {
                //如果是文件夹就递归
                len = len + getLen(file1);
            }
        }
        return len;
    }

统计各种文件数量

public void test() throws IOException {
        File file = new File("D:\\aaa");
        Map<String, Integer> count = getCount(file);
        System.out.println(count);
 
    }
    //统计文件夹大小
    public static Map<String,Integer> getCount(File file){
        //定义集合用来统计
        Map<String,Integer> map = new HashMap();
        File[] files = file.listFiles();
        //遍历数组
        for (File file1 : files) {
            //判断，如果是文件统计
            if (file1.isFile()){
                String name = file1.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 {
                //判断，如果是文件夹，递归
                //sonMap里面是子文件中每一种文件的个数
                Map<String,Integer> sonMap = getCount(file1);
                //遍历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;
    }