File类用于文件操作，下面我来演示以下File类的常用方法

创建File对象

构造器概述

一个File对象绑定一个文件或者文件夹，我们需要在创建对象时绑定文件或者文件夹，这个通过调用FIle类的构造函数来实现

File类的构造器如下

  1. public File(String pathname)

    通过路径名字符串绑定文件或者文件夹

  2. public File(String parent, String child)

    通过父路径字符串+子路径字符串绑定文件或者文件夹

  3. public File(File parent, String child)

    通过父File对象+子路径字符串绑定文件或者文件夹

  4. private File(String child, File parent)

    这个为私有构造器，只能内部调用，就不演示了

  5. private File(String pathname, int prefixLength)

    这个为私有构造器，只能内部调用，就不演示了

构造器演示

public File(String pathname)

1
2
3
// public File(String pathname)
String fileName = "E:\\news.txt";
File file = new File(fileName);

public File(String parent, String child)

1
2
3
4
// public File(String parent, String child)
String parentFileName = "E:\\";
String childFileName = "news.txt";
File file = new File(parentFileName, childFileName);

public File(File parent, String child)

1
2
3
4
// public File(File parent, String child)
File parentFile = new File("E:\\");
String childFileName = "news.txt";
File file = new File(parentFile, childFileName);

exists

判断文件或者文件夹是否存在

存在返回true，不存在返回false

public boolean exists()

1
2
3
4
5
6
File file = new File("E:\\directory");
if (file.exists()) {
	System.out.println("文件已经存在！");
} else {
	System.out.println("文件不存在！");
}

mkdir

创建一级目录

public boolean mkdir()

目录创建成功返回true，创建失败(如目录已经存在)则返回false

1
2
3
4
5
6
File file = new File("E:\\directory");
if (file.mkdir()) {
	System.out.println("目录创建成功！");
	} else {
		System.out.println("目录创建失败！");
}

delete

删除文件或者目录

public boolean delete()

删除成功返回true，删除失败（如要删除的文件或者目录不存在）返回false

1
2
3
4
5
6
File file = new File("E:\\directory");
if (file.delete()) {
	System.out.println("删除成功！");
	} else {
	System.out.println("删除失败！");
}

mkdirs

递归创建多级目录

public boolean mkdirs()

目录创建成功返回true，创建失败(如目录已经存在)则返回false

1
2
3
4
5
6
File file = new File("E:\\directory\\dir");
if (file.mkdir()) {
	System.out.println("多级目录创建成功！");
	} else {
		System.out.println("多级目录创建失败！");
}

createNewFiles

创建文件

public boolean createNewFile() throws IOException

创建成功返回true，创建失败返回false

注意，如果文件路径中包含目录，则目录一定要存在，否则会创建失败，抛出异常

1
2
3
4
5
6
File file = new File("E:\\news.txt");
if (file.createNewFiles()) {
	System.out.println("文件创建成功！");
	} else {
		System.out.println("文件创建失败！");
}

isDirectory

判断是否是目录

public boolean isDirectory()

是目录返回true，不是目录（如文件不存在或者文件不是目录）返回false

1
2
3
4
5
6
File file = new File("E:\\directory");
if (file.isDirectory()) {
	System.out.println("该文件是目录！");
	} else {
	System.out.println("该文件不是目录！");
}

isFile

判断是否是文件

public boolean isFile()

是文件返回true，不是文件（如文件不存在或者是目录）返回false

1
2
3
4
5
6
File file = new File("E:\\directory");
if (file.isFile()) {
	System.out.println("该文件是文件！");
	} else {
	System.out.println("该文件不是文件！");
}

canRead

判断文件是否可读

public boolean canRead()

可读返回true，不可读返回false

1
2
3
4
5
6
File file = new File("E:\\directory");
if (file.canRead()) {
	System.out.println("该文件可读");
} else {
	System.out.println("该文件不可读");
}

canWrite

判断文件是否可写

public boolean canWrite()

可写返回true，不可写返回false

1
2
3
4
5
6
File file = new File("E:\\directory");
if (file.canWrite()) {
	System.out.println("该文件可写");
} else {
	System.out.println("该文件不可写");
}

canExecute

判断文件是否可执行

public boolean canExecute()

可执行返回true，不可执行返回false

1
2
3
4
5
6
File file = new File("E:\\directory");
if (file.canExecute()) {
	System.out.println("该文件可执行");
} else {
	System.out.println("该文件不可执行");
}

isHidden

判断文件是否隐藏

public boolean isHidden()

隐藏返回true、没有隐藏返回false

1
2
3
4
5
6
File file = new File("E:\\directory");
if (file.isHidden()) {
	System.out.println("该文件隐藏了！");
} else {
	System.out.println("该文件没有隐藏");
}

getPath

获得文件或者目录名

public String getName()

1
2
3
4
File file = new File("E:\\directory");
System.out.println(file.getName());
// 输出结果：
// directory

getParent

获得文件或者目录的父级目录

public String getParent()

1
2
3
4
File file = new File("E:\\directory");
System.out.println(file.getParent());
// 输出结果：
// E:\

getAbsolutePath

获得文件或者目录的绝对路径

public String getAbsolutePath()

1
2
3
4
File file = new File("E:\\directory");
System.out.println(file.getAbsolutePath());
// 输出结果：
// E:\directory

getPath

获得文件或者目录的绝对路径

public String getAbsolutePath()

1
2
3
4
File file = new File("E:\\directory");
System.out.println(file.getPath());
// 输出结果：
// E:\directory

getCanonicalPath

获得文件或者目录的规范路径

public String getCanonicalPath() throws IOException

1
2
3
4
File file = new File("E:\\directory");
System.out.println(file.getCanonicalPath());
// 输出结果：
// E:\directory

getFreeSpace

返回文件或者目录所在的磁盘分区空闲的字节数

public long getFreeSpace()

返回结果为字节数，可以将结果换算为kb、mb、gb等等单位

注意：当该文件或者目录存在时才能返回正确结果，否则会返回0

1
2
3
4
5
6
7
8
9
10
11
12
File file = new File("E:\\directory");
// 返回E盘空闲字节数
long freeSpace = file.getFreeSpace();
// 字节转GB，使用BigDecimal是为了得到更加精确的结果
BigDecimal bigDecimal = new BigDecimal(freeSpace);
BigDecimal div1024 = new BigDecimal(1024);
// 1GB = 1024 * 1024 * 1024 字节
BigDecimal result = bigDecimal.divide(div1024).divide(div1024).divide(div1024);
// 输出结果，保留两位小数
System.out.println(String.format("%.2fG", result.doubleValue()));
// 输出结果：
// 31.35G

结果和计算机显示的剩余容量相差无几！

image-20220902120304580

getTotalSpace

返回文件或者目录所在的磁盘总字节数

public long getTotalSpace()

返回结果为字节数，可以将结果换算为kb、mb、gb等等单位

注意：当该文件或者目录存在时才能返回正确结果，否则会返回0

1
2
3
4
5
6
7
8
9
10
11
12
File file = new File("E:\\directory");
//返回E盘总字节数
long totalSpace = file.getTotalSpace();
// 字节转GB
BigDecimal bigDecimal = new BigDecimal(totalSpace);
BigDecimal div1024 = new BigDecimal(1024);
// 1GB = 1024 * 1024 * 1024 字节
BigDecimal result = bigDecimal.divide(div1024).divide(div1024).divide(div1024);
// 输出结果，保留六位小数
System.out.println(String.format("%.6fG", result.doubleValue()));
// 输出结果：
// 49.999996G

结果和计算机显示的总容量相差无几！

image-20220902120304580

getUsableSpace

返回文件或者目录所在的磁盘可用的字节数

public long getUsableSpace()

返回结果为字节数，可以将结果换算为kb、mb、gb等等单位

注意：当该文件或者目录存在时才能返回正确结果，否则会返回0

1
2
3
4
5
6
7
8
9
10
11
12
File file = new File("E:\\directory");
//返回E盘总字节数
long usableSpace = file.getTotalSpace();
// 字节转GB
BigDecimal bigDecimal = new BigDecimal(usableSpace);
BigDecimal div1024 = new BigDecimal(1024);
// 1GB = 1024 * 1024 * 1024 字节
BigDecimal result = bigDecimal.divide(div1024).divide(div1024).divide(div1024);
// 输出结果，保留六位小数
System.out.println(String.format("%.2fG", result.doubleValue()));
// 输出结果：
// 31.35G

结果和计算机显示的可用容量相差无几！

image-20220902120304580

list

返回目录的文件及文件夹的名称，注意只返回一层，而不是多层

public String[] list()

1
2
3
4
5
6
7
File file = new File("E:\\directory");
// 返回目录的文件及文件夹的名称
String[] fireNames = file.list();
// 遍历文件名称
for (String fireName : fireNames) {
	System.out.println(fireName);
}

listFiles

返回目录的文件及文件夹的File对象，注意只返回一层，而不是多层

public File[] listFiles()

1
2
3
4
5
6
7
File file = new File("E:\\directory");
// 返回目录的文件及文件夹的Fire对象
File[] files = file.listFiles();
// 遍历Fire对象们
for(File theFire : files) {
	System.out.println(theFire.getName());
}

getParentFile

获得父级目录的File对象

public File getParentFile()

1
2
3
4
5
6
File file = new File("E:\\directory");
File parentFile = file.getParentFile();
// 输出父级目录的路径
System.out.println(parentFile.getPath());
// 输出结果：
// E:\

renameTo

这个用于改变文件或者文件夹的名字

public boolean renameTo(File dest)

改名后，该文件与dest File对象绑定，此时原来的File对象无法操作改名后的文件或者文件夹，文件操作权转由dest来操控（即File对象只能操作绑定好的文件或文件夹，且File对象一旦绑定好文件或文件夹，就无法再绑定其他文件或文件夹）

改名成功返回true，改名失败（如原来的文件不存在或者改名后的文件已经存在）返回false

细节：

  1. renameTo指定改名后的文件和原文件是同一目录但名称不同时，是改名
  2. renameTo指定改名后的文件和原文件不是同一目录但名称相同时，是移动
  3. renameTo指定改名后的文件和原文件不是同一目录且名称不同时，是改名+移动
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
File file = new File("E:\\news.txt");
File renameFile = new File("D:\\rename.txt");
// 创建news.txt文件
file.createNewFile();
// 改名
if (file.renameTo(renameFile)) {
	System.out.println("文件改名成功！");
} else {
	System.out.println("文件改名失败！");
}
// 判断文件是否存在
System.out.println(file.exists());
System.out.println(renameFile.exists());
// 输出结果：
// 文件改名成功！
// false
// true

length

返回文件或者目录的大小，单位为字节

public long length()

例如这里有个news.txt，其文件大小为11个字节，我们让程序输出其大小

image-20220902150954887

1
2
3
4
File file = new File("E:\\news.txt");
System.out.println(file.length());
// 输出结果：
// 11

deleteOnExit

同样是删除文件，只不过要等虚拟机结束进程后，文件才会真正删除

public void deleteOnExit()

适用场景：临时文件，程序执行时需要，执行完毕后就不需要的文件

1
2
3
4
5
File file = new File("E:\\news.txt");
// 新建文件
file.createNewFile();
// 删除文件，真正操作会在虚拟机进程结束后进行
 file.deleteOnExit();

setReadOnly

设置文件为只读

public boolean setReadOnly()

设置成功返回true，设置失败（如文件已经是只读状态）返回false

1
2
3
4
5
6
File file = new File("E:\\news.txt");
if (file.setReadOnly()) {
System.out.println("设置只读成功！");
	} else {
System.out.println("设置只读失败！");
}

lastModified

返回文件或者目录最后修改的时间，返回值为milliseconds，即从1970-1-1到最后修改的时间这期间经历过的毫秒数

但是我们可以使用日期类转换成我们想要的时间格式

public long lastModified()

文件不存在或者发生I/O错误时返回0L

1
2
3
4
5
6
7
8
9
File file = new File("E:\\news.txt");
file.createNewFile();
// 获得修改时间
long last = file.lastModified();
// 原样输出的结果
System.out.println("milliseconds = " + last);
// 转换格式后
Date date = new Date(last);
System.out.println("转换格式后：" + new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(date));

setLastModified

设置文件最后修改时间

传入时间为milliseconds，即从1970-1-1到最后修改的时间这期间经历过的毫秒数

修改成功返回true，修改失败返回false

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
File file = new File("E:\\news.txt");
// 设置文件修改时间为当前时间
if (file.setLastModified(System.currentTimeMillis())) {
	System.out.println("修改成功！");
} else {
	System.out.println("修改失败！");
}
// 获得修改时间
long last = file.lastModified();
// 原样输出的结果
System.out.println("milliseconds = " + last);
// 转换格式后
Date date = new Date(last);
System.out.println("转换格式后：" + new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(date));
// 输出结果：
// 修改成功！
// milliseconds = 1662104414088
// 转换格式后：2022-09-02 03:40:14

setReadable

设置文件或者目录的可读性

有两种重载形式

  1. public boolean setReadable(boolean readable)

    设置文件是否可读，true为可读，false为不可读

  2. public boolean setReadable(boolean readable, boolean ownerOnly)

    设置文件是否可读

    1. readable：true为可读，false为不可读
    2. ownerOnly：true为所有者可读，false为所有人可读，当且仅当Readable为true时生效

设置成功返回true，设置失败返回false

1
2
3
4
File file1 = new File("E:\\news.txt");
File file2 = new File("E:\\hello.txt");
file1.setReadable(true);
file2.setReadable(true, true);

setWritable

设置文件或者目录的可写性

有两种重载形式

  1. public boolean setWritable(boolean writable)

    设置文件是否可写，true为可写，false为不可写

  2. public boolean setWritable(boolean writable, boolean ownerOnly)

    设置文件是否可写，true为可写，false为不可写

    1. writable：true为可写，false为不可写
    2. ownerOnly：true为所有者可写，false为所有人可写，当且仅当writeable为true时生效

设置成功返回true，设置失败返回false

1
2
3
4
File file1 = new File("E:\\news.txt");
File file2 = new File("E:\\hello.txt");
file1.setWritable(true);
file2.setWritable(true, true);

setExecutable

设置文件或者目录的可执行性

有两种重载形式

  1. public boolean setExecutable(boolean executable)

    设置文件是否可执行，true为可执行，false为不可执行

  2. public boolean setExecutable(boolean executable, boolean ownerOnly)

​ 设置文件是否可执行，true为可执行，false为不可执行

​ 1. executable：true为可执行，false为不可执行

​ 2. ownerOnly：true为所有者可执行，false为所有人可执行，当且仅当executable为true时生效

设置成功返回true，设置失败返回false

1
2
3
4
File file1 = new File("E:\\news.txt");
File file2 = new File("E:\\hello.txt");
file1.setExectuable(true);
file2.setExecutable(true, true);