Java:File类

￡神魔★判官ぃ 2024-03-31 14:27 66阅读 0赞

**目录**

File类

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

2、File类，创建和删除

3、File类 获取并遍历

--------------------

### File类 ###

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

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

常见构造方法

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>方法名</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>public File(String pathname)</td> 
   <td>根据文件路径创建文件对象</td> 
  </tr> 
  <tr> 
   <td>public File(String parent，String child)</td> 
   <td>根据父路径名字符串和子路径名字符串创建文件对象</td> 
  </tr> 
  <tr> 
   <td>public File(File parent，string child)</td> 
   <td>根据父路径对应文件对象和子路径名字符串创建文件对象</td> 
  </tr> 
 </tbody> 
</table>

示例：

//根据字符串表示的路径，变成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的常见成员方法(判断、获取) ####

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>方法名称</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>public boolean isDirectory()</td> 
   <td>判断此路径名表示的File是否为文件夹</td> 
  </tr> 
  <tr> 
   <td>public boolean isFile()</td> 
   <td>判断此路径名表示的File是否为文件</td> 
  </tr> 
  <tr> 
   <td>public boolean exists()</td> 
   <td>判断此路径名表示的File是否存在</td> 
  </tr> 
  <tr> 
   <td>public long length()</td> 
   <td>返回文件的大小（字节数量)</td> 
  </tr> 
  <tr> 
   <td>public string getAbsolutePath()</td> 
   <td>返回文件的绝对路径</td> 
  </tr> 
  <tr> 
   <td>public string getPath()</td> 
   <td>返回定义文件时使用的路径</td> 
  </tr> 
  <tr> 
   <td>public string getName()</td> 
   <td>返回文件的名称，带后缀</td> 
  </tr> 
  <tr> 
   <td>public long lastModified()</td> 
   <td>返回文件的最后修改时间（时间毫秒值)</td> 
  </tr> 
 </tbody> 
</table>

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类，创建和删除 ####

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>方法名称</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>public boolean createNewFile()</td> 
   <td>创建一个新的空的文件</td> 
  </tr> 
  <tr> 
   <td>public boolean mkdir()</td> 
   <td>创建单级文件夹</td> 
  </tr> 
  <tr> 
   <td>public boolean mkdirs()</td> 
   <td>创建多级文件夹</td> 
  </tr> 
  <tr> 
   <td>public boolean delete()</td> 
   <td>删除文件、空文件夹</td> 
  </tr> 
 </tbody> 
</table>

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类 获取并遍历 ####

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>方法名</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>public File[ ] listFiles()</td> 
   <td>获取当前该路径下所有内容</td> 
  </tr> 
 </tbody> 
</table>

//创建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

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>方法名</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>public static File[] listRoots()</td> 
   <td>列出可用的文件系统根</td> 
  </tr> 
  <tr> 
   <td>public string[ ] list()</td> 
   <td>获取当前该路径下所有内容</td> 
  </tr> 
  <tr> 
   <td>public string[ ] list(FilenameFilter filter)</td> 
   <td>利用文件名过滤器获取当前该路径下所有内容</td> 
  </tr> 
  <tr> 
   <td>public File[ ] listFiles()</td> 
   <td>获取当前该路径下所有内容</td> 
  </tr> 
  <tr> 
   <td>public File[] listFiles(FileFilter filter)</td> 
   <td>利用文件名过滤器获取当前该路径下所有内容</td> 
  </tr> 
  <tr> 
   <td>public File[] listFiles(FilenameFilter filter)</td> 
   <td>利用文件名过滤器获取当前该路径下所有内容</td> 
  </tr> 
 </tbody> 
</table>

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;
        }