File类的介绍和常用方法的使用

清风冉起

已于 2022-12-08 09:24:32 修改

阅读量1.1k

点赞数 2

文章标签： java 开发语言

于 2022-12-07 20:38:22 首次发布

本文链接：https://blog.csdn.net/m0_73671382/article/details/128224861

版权

1.File类

概述

java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。

File类和四大家族没有关系，所以File类不能完成文件的读和写
File对象代表什么？ - 文件和目录路径名的抽象表示形式 - 例如： D:\java_study 这是一个File对象 D:\java_study\java_note.txt 这也是一个File对象 - 一个File对象有可能对应的是目录，也可能是文件。 File只是一个路径名的抽象表示形式。

2.常用的方法使用：

成员变量

File.PathSeparator 路径分隔符 windows下为分号，linux下为冒号
　　File.separator 文件名称分隔符 windows下为：\ linux下为：/
　　需要注意的是windows下也能识别 /，所以我们一般用 /

static  String  pathSeparator
static  String  separator
System.out.println(File.pathSeparator);
System.out.println(File.separator);

File类创建和获取功能：

方法	说明
createNewFile()	以文件的形式创建出来
mkdir ()	以目录的形式创建出来
mkdirs()	以多重目录的形式新建
delete()	删除某个文件或目录
deleteOnExit()	删除某个文件或目录并退出
getParent()	获取该文件的父路径
getParentFile()	返回该路径名的父目录的路径名
getAbsolutePath()	获取绝对路径
getName()	获取文件名
isDirectory()	判断是否是一个目录
isFile()	判断是否是一个文件
lastModified()	获取最后一次该文件的修改时间
listFiles()	获取当前目录下所有的子文件，重点

代码案例：

//1.    boolean exists()判段文件或目录是否在硬盘上存在。 
		boolean exists = file.exists();//可以用来对文件的操作前非空判断
		System.out.println("文件夹A" + exists);
//2.	boolean isDirectory() 	判断当前对象是不是文件夹.
		System.out.println(file.isDirectory());
//3.	long length()  获取文件的字节数，文件夹不能直接获取字节数
		long length = file3.length();//计算一个文件夹的大小先判断是不是文件夹。
		System.out.println("t.txt" + length);
//4.	String getName()  获取文件(或者文件夹)名（不包含上级目录）.
 	 	String name = file3.getName();
//5.  	String getParent() 获取父路径String格式，相对路径不能获取父级目录(没有层级结构的).
		String parent = file3.getParent();
//6.	File getParentFile() 获取父类路径的File对象.
		File parentFile = file3.getParentFile();	
//7.	static File[] listRoots()  获取当前系统的所有盘符或者根目录.
		System.out.println(Arrays.toString(File.listRoots()));//[C:\, D:\]
//8.	boolean renameTo(File dest) 重命名当前文件或文件夹对象 .
		boolean renameTo = file2.renameTo(file3);
//9.	Path toPath()  将当前文件或文件夹对象转换为Path类型，JavaWeb中做文件上传的时候用到
		Path path = file4.toPath();
//10.	String getAbsolutePath() 获取文件夹或者文件绝对路径名字符串。
		File absoluteFile = file3.getAbsoluteFile();

获取功能的方法:

public String getAbsolutePath() : 返回此File的绝对路径名字符串。
public String getPath() :将此File转换为路径名字符串。
public string getName() : 返回由此File表示的文件或目录的名称。
public long length() : 返回由此File表示的文件的长度。

代码案例：

import java.io.File;

public class FileTest3 {
    public static void main(String[] args) {
        File f1=new File("d:/aaa/bbb.java");
        System.out.println("文件绝对路径:"+f1.getAbsolutePath());
        System.out.println("文件构造路径:"+f1.getPath());
        System.out.println("文件名称:"+f1.getName());
        System.out.println("文件长度:"+f1.length()+"字节");

        File f2=new File("d:/aaa");
        System.out.println("目录绝对路径:"+f2.getAbsolutePath());
        System.out.println("目录构造路径:"+f2.getPath());
        System.out.println("目录名称:"+f2.getName());
        System.out.println("目录长度:"+f2.length());
    }
}

输出结果：
文件绝对路径:d:\aaa\bbb.java
        文件构造路径:d:\aaa\bbb.java
        文件名称:bbb.java
        文件长度:0字节
        目录绝对路径:d:\aaa
        目录构造路径:d:\aaa
        目录名称:aaa
        目录长度:0

API中说明：length()，表示文件的长度。但是File对象表示目录，则返回值未指定

判断功能的方法

public boolean exists() : 此File表示的文件或目录是否实际存在。
public boolean isDirectory() :此Fle表示的是否为目录。
public boolean isFile() : 此File表示的是否为文件。

代码案例：

public class FileIs{
public static void main(String[] args) {
File f1 = new File("d:\\aaa\\bbb.java");
File f2 = new File("d:\\aaa");
// 判断是否存在
System.out.println(d:\\aaa\\bbb.java 是否存在:"+f.exists());
System.out.printIn("d:\\aaa 是否存在:"+f2.exists());
// 判断是文件还是目录
System.out.println("d:\\aaa 文件?:"+f2.isFile());
System.out.printn("d:\\aaa 目录?:"+f2.isDinectory());
     }
}



输出结果:d:\aaa\bbb.java 是否存在:true
d:\aaa 是否存在:true
d: \aaa文件?:false
d:\aaa 目录?;true

File类高级获取功能

public File[] listFiles() // 返回此抽象路径名表示的目录中的文件和目录的File对象数组

注意事项：

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

统计一个文件夹内的文件类型(不包含嵌套)

public class Test2 {
    public static void main(String[] args) {
        HashMap<String, Integer> hm = new HashMap<>();

        File f = new File("day10\\统计文件个数文件夹");
        File[] files = f.listFiles();
        for (File file : files) {
            if (file.isDirectory()) {
                // 如果是目录
                add("文件夹", hm);
            } else {
                // 如果是文件
                String fileName = file.getName();
                String[] splits = fileName.split("\\.");
                String trueName = splits[splits.length - 1];
                add(trueName, hm);
            }
        }

        // 遍历结果
        Set<Map.Entry<String, Integer>> entries = hm.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + ":" + value + "个");
        }
    }

    public static void add(String name, HashMap<String, Integer> hm) {
        if (hm.containsKey(name)) {
            hm.put(name, hm.get(name) + 1);
        } else {
            hm.put(name, 1);
        }
    }
}

构造方法：

public File(String pathname) : 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
public File(String parent，String child) : 从父路径名字符串和子路径名字符串创建新的 File实例。
public File(File parent，String child) : 从父抽象路径名和子路径名字符串创建新的 File实例。

代码案例：

import java.io.File;

public class FileTest2 {
    public static void main(String[] args) {
        //File的构造方法比较灵活，可以根据具体的需要选择使用
        File f1=new File("D:/aa/hello.txt");
        File f2=new File("d:/aa","hello.txt");
        File file=new File("d:/aa");
        File f3=new File(file,"hello.txt");
    }
}

方法	说明
File(File parent, String child)	根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例
File(String pathname)	通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例
File(String parent, String child)	根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例
File(URI uri)	通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例

File类创建功能：

方法名	说明
boolean createNewFile()	当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件
boolean mkdir()	创建此抽象路径名指定的目录
boolean mkdirs()	创建此抽象路径名指定的目录，包括所有必需但不存在的父目录

普通方法（常用）

1.当只是创建了文件对象时，可以调用方法在具体的路径下面创建文件或者文件夹。

boolean mkdir() 在硬盘创建一个文件夹对象。
boolean createNewFile() 在硬盘创建一个文件对象。

代码案例：

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

public class FileTest {
    public static void main(String[] args) throws IOException {
        File f1=new File("d:/aa/bb/cc");
        File f2=new File(f1,"a.txt");

        //mkdir创建单个文件夹，mkdirs自动不全所有的月灵结构，推荐使用mkdirs
        f1.mkdirs();

        //1.月录结构不存在，程序异常:2.目录结构存在且文件不存在则创建空文件:3.目录结构存在且文件存在不做任何操作
        f2.createNewFile();

    }
}

创建和删除功能方法

boolean createNewFile() 当且仅当当前该名称文件尚不存在时，创建一个新的文件
boolean delete() 删除由此File表示的文件或目录，若要删除的是目录且目录里面有内容则

删除

public boolean delete() // 删除由此抽象路径名表示的文件或目录

注意事项：

delete方法直接删除不走回收站
如果删除的是一个文件，直接删除
如果删除的是一个文件夹，需要先删除文件夹中的内容，最后才能删除文件夹

相对路径和绝对路径

绝对路径：从盘符开始

File file1 = new File(“D:\\itheima\\a.txt”);

相对路径：相对于当前项目下的路径

File file2 = new File(“a.txt”);
File file3 = new File(“模块名\\a.txt”);

绝对路径和相对路径的区别：

绝对路径：完整的路径名，不需要任何的其他信息就可以定位它所表示的文件。

相对路径：必须使用取自其他路径的信息进行解释。

删除目录的注意事项：

如果一个目录中有内容(目录，文件)，不能直接删除。应该先删除该目录下的内容，最后删除该目录

代码案例：

package com.ithmm_01;

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

public class FileDemo04 {
    public static void main(String[] args) throws IOException {
        //需求1：在当前模块目录下创建java.txt 文件
        File f =  new File("Io\\java.txt");

        //需求2：删除当前模块目录下的java.txt 文件
        System.out.println(f.delete());

        //需求3：在当前模块目录下创建ithmm目录
        File f2 = new File("Io\\ithmm");
       // System.out.println(f2.mkdir());
        System.out.println(f2.delete());

        //需求4：在当前模块目录下创建ithmm,然后在该目录下创建一个文件java.txt
        File f3 = new File("Io\\ithmm");
        System.out.println(f3.mkdir());
        File f4 = new File("Io\\ithmm\\java.txt");
        System.out.println(f4.createNewFile());

        
        //需求6：删除当前目录ithmm，首先要删除该目录下的文件
        System.out.println(f4.delete());
        System.out.println(f3.delete());
    }
}

不会删除

boolean mkdir() 创建由此File表示的目录
boolean mkdirs() 创建由此File表示的目录，包括任何必须但不存在的父目录

		//在内存中创建一个文件夹对象，当前文件夹对象是指最后一级c
		File dir2 = new File("D:/a/b/c");//file指代c文件夹。
		//在硬盘创建多层级的文件夹对象。  
		boolean mkdirs = dir2.mkdirs();

3.目录的遍历

public string[] list() : 返回一个String数组，表示该File目录中的所有子文件或目录。
public File[] listFiles() : 返回一个Fle数组，表示该File目录中的所有的子文件或目录。

如果遍历的路径不是一个目录，则会抛出空指针异常

代码案例：

import java.io.File;

public class FileTest4 {
    public static void main(String[] args) {
        File dir=new File("d:\\java_code");

        //获取当前目录下的文件以及文件夹的名称
        String[] names=dir.list();
        for (String name:names){
            System.out.println(name);
        }
        //获取当前目录下的文件以及文件夹对象，只要拿到了文件对象，那么就可以获取更多信息
        File[] files=dir.listFiles();
        for (File file:files){
            System.out.println(file);
        }
    }
}

小贴士：

调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历。

其他方法

boolean endsWith(String s)；后缀是否是字符串s

4.递归

4.1概述

递归：指在当前方法内调用自己的这种现象。
递归的分类：

逃归分为两种，直接递归和间接递归。
直接递归称为方法自身调用自己。
间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。

注意事项：

递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
构造方法,禁止递归

自己调用自己称之为递归递(调用自己) 归(条件判断)

调用方法是递进入方法内部，方法反码执行完毕归来到调用的地方；

案例：

public class FileTest8 {
    static int count=1;
    public static void main(String[] args) {
            //自己调用自己称之为递归 递(调用自己) 归(条件判断)
            System.out.println("====1====");
            System.out.println("====2====");
            System.out.println("====3====");
            fun();
            System.out.println("====4====");
            System.out.println("====5====");
            System.out.println("====6====");
        }
        public static void fun(){
            System.out.println("====fun1====");
            System.out.println("====fun2====");
            count++;
            //判断终止条件
            if(count>3){
                return;
            }
            fun();
            System.out.println("====fun3====");
            System.out.println("====fun4====");
        }
    }

输出结果：


====1====
====2====
====3====
====fun1====
====fun2====
====fun1====
====fun2====
====fun1====
====fun2====
====fun3====
====fun4====
====fun3====
====fun4====
====4====
====5====
====6====

使用递归打印1-10

public class FileTest7 {
    public static void main(String[] args) {
        print(10);
    }
    public static void print(int n) {
        System.out.println(n);
        n--;
        if (n>0){
            print(n);
        }else {
            return;
        }
    }
}