File类

File

概述

File: 路径

IO流: 传输

路径

相对路径, 绝对路径

File

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

构造方法

在这里插入图片描述

代码示例:

package FileTest1;

import java.io.File;

public class FileDemo1 {
    public static void main(String[] args) {
        // 构造方法
        String str = "D:\\java\\Java知识点.docx";
        // 根据字符串表示的路径, 变成File对象
        File file1 = new File(str);
        System.out.println(file1);

        // 父级路径: D:\java
        // 子级路径: Java知识点.docx
        String parent = "D:\\java";
        String child = "Java知识点.docx";
        File file2 = new File(parent, child);
        System.out.println(file2);

        // 把一个File表示的路径和String表示的路径进行拼接
        File parent2 = new File("D:\\java");
        String child2 = "Java知识点.docx";
        File f3 = new File(parent2, child2);
        System.out.println(f3);
    }
}

小结:

File表示什么?
File对象表示路径，可以是文件、也可以是文件夹这个路径可以是存在的，也可以是不存在的

绝对路径和相对路径是什么意思?
绝对路径是带盘符的。
相对路径是不带盘符的，默认到当前项目下去找

常见成员方法

判断和获取类

在这里插入图片描述

代码演示:

package FileTest1;

import java.io.File;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.format.DateTimeFormatter;
import java.util.Date;

public class Demo2 {
    public static void main(String[] args) {
        // 判断类
        // 判断是否为文件夹, 文件 以及 路径名表示的File是否存在
        String str = "D:\\java\\Java知识点.docx";
        File f1 = new File(str);
        System.out.println(f1.isDirectory()); // false
        System.out.println(f1.isFile()); // true
        System.out.println(f1.exists()); // true

        // 获取类
        long len1 = f1.length();
        System.out.println(len1); // 58653
        // length()方法如果直接获取文件夹的大小 会返回0

        String path1 = f1.getAbsolutePath();
        System.out.println(path1); // D:\java\Java知识点.docx

        String path2 = f1.getPath();
        System.out.println(path2); // D:\java\Java知识点.docx

        String name = f1.getName();
        System.out.println(name); // Java知识点.docx

        long l = f1.lastModified();
        System.out.println(l); // 1697373332981
        // 毫秒转正常格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = sdf.format(l);
        System.out.println(format); // 2023-10-15 20:35:32
    }
}

创建和删除类

在这里插入图片描述

创建:

package FileTest1;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;

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

        // 2.mkdir 创建单级目录
        File f3 = new File("D:\\java\\FileTest\\bbb");
        boolean b4 = f3.mkdir();
        System.out.println(b4); // true
        File f4 = new File("D:\\java\\FileTest\\ccc\\ddd");
        boolean b5 = f4.mkdir();
        System.out.println(b5); // false
        /*
        * 细节1: windows当中路径是唯一的，如果当前路径已经存在，则创建失败，返回false
        * 细节2: mkdir方法只能创建单级文件火，无法创建多级文件夹。
        * */

        // 3.mkdirs 创建多级文件夹
        File f5 = new File("D:\\java\\FileTest\\ccc\\ddd");
        boolean b6 = f5.mkdirs();
        System.out.println(b6); // true
        // 细节: 既可以创建单机文件夹, 也可以创建多级文件夹
        // 所以mkdir这个方法很少用
    }
}

删除

package FileTest1;

import java.io.File;

public class Demo4 {
    public static void main(String[] args) {
         /*
        public boolean delete()             删除文件、空文件夹
        细节：
            如果删除的是文件，则直接删除，不走回收站。
            如果删除的是空文件夹，则直接删除，不走回收站
            如果删除的是有内容的文件夹，则删除失败
      */


        //1.创建File对象
        File f1 = new File("D:\\aaa\\eee");
        //2.删除
        boolean b = f1.delete();
        System.out.println(b); // false
    }
}

获取并遍历

listFile() 方法

细节:

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

package com.itheima.a01myfile;

import java.io.File;

public class FileDemo6 {
    public static void main(String[] args) {

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


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

其他方法了解即可

在这里插入图片描述

package com.itheima.a01myfile;


import java.io.File;
import java.io.FilenameFilter;
import java.util.Arrays;

public class FileDemo7 {
    public static void main(String[] args) {

      /*
        public static File[] listRoots()                列出可用的文件系统根
        public String[] list()                          获取当前该路径下所有内容
        public String[] list(FilenameFilter filter)     利用文件名过滤器获取当前该路径下所有内容
        （掌握）public File[] listFiles()                获取当前该路径下所有内容
        public File[] listFiles(FileFilter filter)      利用文件名过滤器获取当前该路径下所有内容
        public File[] listFiles(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));
    }
}

package com.itheima.a01myfile;

import java.io.File;

public class FileDemo8 {
    public static void main(String[] args) {
      /*
        （掌握）public File[] listFiles()                获取当前该路径下所有内容
        public File[] listFiles(FileFilter filter)      利用文件名过滤器获取当前该路径下所有内容
        public File[] 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);
            }
        }
    }
}

package com.itheima.a01myfile;

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

public class FileDemo9 {
    public static void main(String[] args) {
         /*
        public File[] listFiles(FileFilter filter)      利用文件名过滤器获取当前该路径下所有内容
        public File[] listFiles(FilenameFilter filter)  利用文件名过滤器获取当前该路径下所有内容
      */

        //创建File对象
        File f = new File("D:\\aaa");
        //调用listFiles(FileFilter filter)
        File[] arr1 = f.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.isFile() && pathname.getName().endsWith(".txt");
            }
        });

        //调用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

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

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

        //1.创建a.txt的父级路径
        File file = new File("myfile\\aaa");
        //2.创建父级路径
        //如果aaa是存在的，那么此时创建失败的。
        //如果aaa是不存在的，那么此时创建成功的。
        file.mkdirs();
        //3.拼接父级路径和子级路径
        File src = new File(file,"a.txt");
        boolean b = src.createNewFile();
        if(b){
            System.out.println("创建成功");
        }else{
            System.out.println("创建失败");
        }
    }
}

练习2

定义一个方法找某一文件夹中, 是否有以avi结尾的电影(暂时不考虑子文件夹)

package com.itheima.a02test;

import java.io.File;

public class Test2 {
    public static void main(String[] args) {
        /*需求：
             定义一个方法找某一个文件夹中，是否有以avi结尾的电影。
	        （暂时不需要考虑子文件夹）
        */

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

练习3

找到电脑中所有以avi结尾的电影(需要考虑子文件夹)

package com.itheima.a02test;

import java.io.File;

public class Test3 {
    public static void main(String[] args) {
       /* 需求：
        找到电脑中所有以avi结尾的电影。（需要考虑子文件夹）
        套路：
            1，进入文件夹
            2，遍历数组
            3，判断
            4，判断
        */
        findAVI();
    }
    public static void findAVI(){
        //获取本地所有的盘符
        File[] arr = File.listRoots();
        for (File f : arr) {
            findAVI(f);
        }
    }
    public static void findAVI(File src){//"C:\\
        //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

删除一个多级文件夹

public class Test4 {
    public static void main(String[] args) {
        /*
           删除一个多级文件夹
           如果我们要删除一个有内容的文件夹
           1.先删除文件夹里面所有的内容
           2.再删除自己
        */
        File file = new File("D:\\aaa\\src");
        delete(file);
    }
    /*
    * 作用：删除src文件夹
    * 参数：要删除的文件夹
    * */
    public static void delete(File src){
        //1.先删除文件夹里面所有的内容
        //进入src
        File[] files = src.listFiles();
        //遍历
        for (File file : files) {
            //判断,如果是文件，删除
            if(file.isFile()){
                file.delete();
            }else {
                //判断,如果是文件夹，就递归
                delete(file);
            }
        }
        //2.再删除自己
        src.delete();
    }
}

练习5

统计文件夹大小

package Practice;

import java.io.File;

public class Teat5 {
    public static void main(String[] args) {
        // 统计文件夹大小
        File f = new File("D:\\BaiduNetdisk");
        long len = getLen(f);
        System.out.println(len / 1024 / 1024);
    }

    private static long getLen(File f) {
        int len = 0;
        File[] files = f.listFiles();
        for (File file : files) {
            if(file.isFile()){
                len += file.length();
            }
            else{
                len += getLen(file);
            }
        }
        return len;
    }
}

练习6

统计各种类型文件的数量

package com.itheima.a02test;

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

public class Test6 {
    public static void main(String[] args) throws IOException {
       /*
            需求：统计一个文件夹中每种文件的个数并打印。（考虑子文件夹）
            打印格式如下：
            txt:3个
            doc:4个
            jpg:6个
        */
        File file = new File("D:\\aaa\\src");
        HashMap<String, Integer> hm = getCount(file);
        System.out.println(hm);
    }

    /*
    * 作用：
    *       统计一个文件夹中每种文件的个数
    * 参数：
    *       要统计的那个文件夹
    * 返回值：
    *       用来统计map集合
    *       键：后缀名 值：次数
    *
    *       a.txt
    *       a.a.txt
    *       aaa（不需要统计的）
    * */
    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{
                        //不存在
                        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;
    }
}