Java File类学习笔记2：File类对象及常用操作方法

一、 文件、相对路径与绝对路径

1.文件

 (1)标准文件：就像图片，音乐文件等。

 (2)目录文件：也就是平常所说的文件夹。

 (3)虚拟内存文件：系统在运行程序时生成的临时性文件。

2.文件的路径

 (1)相对路径：相对于某一文件的路径，形象地说是把两文件的绝对路径相同的部分砍掉，剩下的就是相对路径

 如：

  A文件是"D:\MyDocuments\StudySample\src\cn\xmh",

  B文件是"D:\MyDocuments\StudySample\src\netjava\cjl",

  则B相对A的路径是"\netjava\cjl";

 (2)绝度路径：从磁盘根目录算起的路径名

  如："G:\TDDOWNLOAD\数据结构"

3.关于系统路径分隔符

在Windows中，使用反斜杠“\”作为路径分割符，比如“c:\test”，但是Java中反斜杠表示转义，所以需要用“C：\\test”在程序中来表示路径。还可以使用“C：/test”进行路径的表示，这种表示方法在linux中也适用。
同时也可以使用File类中定义的常量separator来代替路径分割符，这样在各个系统中都可以使用。
如File file = new File("c:" + File.separator
+ "test.txt”);
单独的separater表示根的意思，如果在根下创建文件，相当于在程序路径的根路径下创建文件。
二、File类对象及常用操作方法

1.最常用的一种，根据字符串型的路径名创建文件对象

在整个IO包中，唯一表示与文件本身有关的类就是File类。我们可以用File类创建文件对象，并对文件对象进行各种操作，

publicFile(String pathname)实例化File类的时候，必须设置好路径

示例：

import java.io.File;
public class FileDemo {
public static void main(String[] args) {
// 构造函数File(String pathname)
File f1 = new File("d:\\daxiang\\1.txt");
// File(String parent,String child)
File f2 = new File("d:\\daxiang", "2.txt");
// File(File parent,String child)
File f3 = new File("d:" + File.separator + "abc");// separator 跨平台分隔符
File f4 = new File(f3, "3.txt");
System.out.println(f1);// d:\daxiang\1.txt
System.out.println(f2);// d:\daxiang\2.txt
System.out.println(f3);// d:\abc
System.out.println(f4);// d:\abc\3.txt
}
}

注意：在使用File类指定路径的时候一定要注意操作系统间的差异，尽量使用separator进行分割

2.文件对象操作方法

要想使用File类，则首先要观察File类的方法，此类的常用方法如下所示：



上面表格中只列出了常用方法的的一部分，下面再分类列举出常用的方法：

创建方法
(1)boolean createNewFile()  //用来创建标准文件的方法
使用File file = new File(path)只是指定了文件创建的路径，但是文件还没有生成，另外如果路径不存在，那么文件将不会创建成功
(2)boolean mkdir()  //创建目录:根据File对象的名字(路径)创建一个目录(文件夹)，如果是相对目录，则新建的目录在当前目录下

(3)boolean mkdirs()  //创建多级目录：如果File对象名字有多级目录，则可以调用该方法一次性创建多级目录
mkdirs()可以建立多级文件夹(目录)， mkdir()只能创建一层目录

如:

Filefile = new File("c:/aa");

file.mkdir(); //这样可以在c:/下创建aa目录

假如有多层目录,则不能用mkdir创建，如:

Filefile = new File("c:/aa/bb");

file.mkdir() //这样创建不了.

这样不会建立任何目录， 因为找不到/tmp/one/two目录， 结果返回false

应该改为:mkdirs()

删除方法

(1)boolean delete()

(2)boolean deleteOnExit()  //文件使用完成后删除

判断方法
(1)boolean canExecute()  //判断文件是否可执行

(2)boolean canRead()  //判断文件是否可读

(3)boolean canWrite()  //判断文件是否可写

(4)boolean exists()  //判断文件是否存在

(5)boolean isDirectory() //判断File对象指向的文件是否为目录，返回一个boolean类型的值，true或者false

(6)boolean isFile() //判断File对象指向的文件是否是标准文件，返回一个boolean类型的值，true或者false

(7)boolean isHidden()

(8)boolean isAbsolute()  //判断是否是绝对路径 文件不存在也能判断
获取方法
(1)StringgetName()  //获取文件的名字(不带文件的路径)，返回的是String类型的值

(2)String getPath()

(3)String getAbsolutePath()

(4)String getParent()  //如果没有父目录返回null

(5)long lastModified()  //获取最后一次修改的时间

(6)long length()  //得到File对象指向文件的长度，以字节计算，返回一个长整形的值(long)
   注意：在系统中，文件夹(目录)的大小为零，也就是不占用空间，使用length()时返回的是0

(7)boolean renameTo(File f)  //重新命名此抽象名称指定的文件
f-- 新抽象路径名的抽象路径名，如果重命名成功此方法返回true，否则返回false

(8)File[] listRoots()  //返回抽象路径名数组，表示在目录中此抽象路径名表示，满足指定过滤器的文件和目录。

(9)String[] list() 

(10)String[] list(FilenameFilter filter)

各个方法的简单实现如下：

import java.io.File;

public class FileExercise {
public static void main(String[] args) throws Exception {

System.out.println("当前操作系统的名称分隔符是：" + java.io.File.separator);
System.out.println("当前操作系统的路径分隔符是：" + java.io.File.pathSeparator);
// 字符串类型的文件名
String fileName = "daxiang.txt";
// 实例化文件对象
File file = new File("src", fileName);
File file1 = new File("D:\\daxiang\\testjava\\src\\txt");
File file2 = new File("D:\\daxiang\\testjava\\src");
// 创建一个文件
file.createNewFile(); //注意file是抽象路径，此时会在当前java工程下的src文件夹下创建一个daxiang.txt文件

boolean b;// 申明一个boolean类型的变量

// 测试应用程序是否可以执行该文件
b = file.canExecute();
System.out.println("测试应用程序是否可以执行该文件" + b);

// 测试用用程序是否可以读取该文件
b = file.canRead();
System.out.println("测试用用程序是否可以读取该文件" + b);

// 测试用用程序是否可以修改该文件
b = file.canWrite();
System.out.println("测试用用程序是否可以修改该文件" + b);

// 测试此抽象路径名表示的文件或目录是否存在。
b = file.exists();
System.out.println("测试此抽象路径名表示的文件或目录是否存在" + b);

// 按字母顺序比较两个抽象路径名
int i = file.compareTo(file1); //compareTo方法，返回参与比较的前后两个字符串的ASCII码的差值
System.out.println(i);

String path;
// 返回此抽象路径名的绝对路径名字符串
path = file.getAbsolutePath();
System.out.println(path);

// 返回此抽象路径名的规范路径名字符串
path = file.getCanonicalPath();
System.out.println(path);

long free;
// 返回此抽象路径名指定的分区中未分配的字节数
free = file.getFreeSpace();
System.out.println("此抽象路径名指定的分区中未分配的字节数" + free);

// 返回由此抽象路径名表示的文件或目录的名称
String name;
name = file.getName();
System.out.println(name);
name = file1.getName();
System.out.println(name);

// 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null
String parentpath;
parentpath = file.getParent();
System.out.println(parentpath);
parentpath = file1.getParent();
System.out.println(parentpath);

// 返回此抽象路径名指定的分区上可用于此虚拟机的字节数
free = file.getUsableSpace();
System.out.println("此抽象路径名指定的分区上可用于此虚拟机的字节数" + free);

// 计算此抽象路径名的哈希码
i = file.hashCode();
System.out.println(i);

// 测试此抽象路径名是否为绝对路径名
b = file.isAbsolute();
System.out.println("file对象的抽象路径名是否为绝对路径名：" + b);
b = file1.isAbsolute();
System.out.println("file1对象的抽象路径名是否为绝对路径名：" + b);

// 返回此抽象路径名表示的文件最后一次被修改的时间
long time = file.lastModified();
System.out.println(time);

// 返回由此抽象路径名表示的文件的长度
long length = file.length();
System.out.println("文件的长度:" + length);
System.out.println();

// 注意list()和listFile()的区别
// list()-->返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录
String[] array1 = file2.list();
for (i = 0; i < array1.length; i++) {
System.out.println(array1[i]);
}
System.out.println();

// listFiles()-->返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件
File[] array2 = file2.listFiles();
for (i = 0; i < array2.length; i++) {
System.out.println(array2[i]);
}
System.out.println();

// listRoots()-->列出可用的文件系统根,静态方法
File[] roots = File.listRoots();
for (i = 0; i < roots.length; i++) {
System.out.println(roots[i]);
}
System.out.println();

// 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。
// file.deleteOnExit();

// 创建此抽象路径名指定的目录
file1.mkdir();
// 重新命名此抽象路径名表示的文件
File file4 = new File("src\\重命名文件");
System.out.println(file1.renameTo(file4));
// 设置文件只读
file.setReadOnly();
// 设置文件可写
file.setWritable(true);
}
}

三、File类常用操作实例

<span style="font-size:14px;">/**
* 实例操作一：创建一个新文件
* 在D盘创建一个test.txt文件
*/
import java.io.File;
import java.io.IOException;

public class FileOperate {
public static void main(String[] args) {
File f = new File("d:" + File.separator + "test.txt");// 为增加可移植性，建议使用File.separator
try {
f.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
}

/**
* 实例操作二：删除一个指定文件
* 删除刚刚在D盘创建的test.txt文件
*/
import java.io.File;

public class FileOperate {
public static void main(String[] args) {
File f = new File("d:" + File.separator + "test.txt");
if (f.exists()) {// 判断文件存不存在，如不存在就不用删除了
f.delete();
}
}
}

/**
* 实例操作三：综合创建、删除文件的操作
* 给定一个路径，如果此文件存在，则删除，如果不存在，则创建
*/
import java.io.File;
import java.io.IOException;

public class FileOperate {
public static void main(String[] args) {
File f = new File("d:" + File.separator + "test.txt");
if (f.exists()) {
f.delete();
} else {
try {
f.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

/**
* 实例操作四：创建一个文件夹
* 使用mkdir()方法创建一个文件夹
*/
import java.io.File;

public class FileOperate {
public static void main(String[] args) {
File f = new File("d:" + File.separator + "test");
f.mkdir();// 创建文件夹
}
}

/**
* 实例操作五：列出指定目录的全部文件
* 如果现在给出了一个目录，则可以直接列出目录中的内容。但是列出的方法在File类中存在两个：
* 以字符串数组的形式返回：public String[] list()
* 以File数组的形式返回：public File[] listFiles()
*/
/**
* 实例操作五：列出指定目录的全部文件
* 操作一：使用list()列出全部内容
* 该方法列出了D盘下的文件夹和文件的名字
*/
import java.io.File;

public class FileOperate {
public static void main(String[] args) {
File f = new File("d:" + File.separator);
String[] str = f.list();
for (String s : str) {
System.out.println(s);
}
}
}

/**
* 实例操作五：列出指定目录的全部文件
* 操作二：使用listFiles()列出
* 列出了完全路径
*/
import java.io.File;

public class FileOperate {
public static void main(String[] args) {
File f = new File("d:" + File.separator);
File[] files = f.listFiles();
for (File file : files) {
System.out.println(file);
}
}
}

/**
* 实例操作六：判断一个给定的路径是否目录
* 给定路径，判断是否是目录
*/
import java.io.File;

public class FileOperate {
public static void main(String[] args) {
File f = new File("d:" + File.separator);
if (f.isDirectory()) {
System.out.println(f.getPath() + "是目录");
} else {
System.out.println(f.getPath() + "不是目录");
}
}
}

/**
* 实例操作七：列出指定目录的全部内容(递归)
* 如果给定了一个目录，则要求把此目录中的全部文件都列出来，包括子文件夹下的文件
*/
import java.io.File;
public class FileOperate {
public static void main(String[] args) {
File f = new File("d:" + File.separator);
print(f);
}

public static void print(File f) {
if (f != null) {
if (f.isDirectory()) {
File[] files = f.listFiles();
if (files != null) {
for (File file : files) {
print(file);
}
}
} else {
System.out.println(f);
}
}
}
}

/**
* 实例操作八：列出磁盘下的路径名
* @param public static File[] listRoots()
* @return 该方法返回指示可用的文件系统的根文件对象的数组。如果不能确定该组的根该方法返回null。
*/
import java.io.File;
public class FileDemo {
public static void main(String[] args) {

File[] paths;

try {
// returns pathnames for files and directory
paths = File.listRoots();

// for each pathname in pathname array
for (File path : paths) {
// prints file and directory paths
System.out.println(path);
}
} catch (Exception e) {
// if any error occurs
e.printStackTrace();
}
}
}

/**
* 实例操作九：列出磁盘下的文件和文件夹
* @param public static File[] listRoots()
* @return 该方法返回指示可用的文件系统的根文件对象的数组。如果不能确定该组的根该方法返回null。
*/
import java.io.File;

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

File[] files = File.listRoots();
for (File file : files) {
System.out.println(file);
if (file.length() > 0) {
String[] filenames = file.list();
for (String filename : filenames) {
System.out.println(filename);
}
}
}
}
}

/**
* 实例操作十：文件过滤
* @param FilenameFilter类
* @return
*/
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;

public class FileDemo {
public static void main(String[] args) throws IOException {

File dir = new File("d:\\daxiang\\testjava");

File[] files = dir.listFiles(new FilenameFilter() {
// 获取.java文件时使用listFiles(FilenameFilter filter)方法，创建一个过滤文件名的Filter
public boolean accept(File dir, String name) {
if (name != null && "".equals("")) {
// 检测文件名是否是以.saz结尾，是返回true，否则继续检测下一个文件
if (name.toLowerCase().endsWith(".java")) {
return true;
}
}
return false;
}
});

for (File file : files) {
System.out.println(file);
}
}
}</span>

四、file.getPath()getAbsolutePath()
getCanonicalPath()区别

可以参考的文章：File类的getPath、getAbsolutePath和getCanonicalPath的不同

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

public class getFilePath {
public static void main(String[] args) throws IOException {
System.out.println("------默认相对路径，取得路径不同-----");
File f = new File("..\\src\\file");
System.out.println(f.getPath());
System.out.println(f.getAbsolutePath());
System.out.println(f.getCanonicalPath());
System.out.println("------默认相对路径，取得路径不同-----");
File f2 = new File(".\\src\\file");
System.out.println(f2.getPath());
System.out.println(f2.getAbsolutePath());
System.out.println(f2.getCanonicalPath());
System.out.println("------默认绝对路径，取得路径相同-----");
File f3 = new File("C:\\src\\file");
System.out.println(f3.getPath());
System.out.println(f3.getAbsolutePath());
System.out.println(f3.getCanonicalPath());

// 执行结果为：
// ------默认相对路径，取得路径不同-----
// ..\src\file
// C:\workspace\Tip\..\src\file
// C:\workspace\src\file
// ------默认相对路径，取得路径不同-----
// .\src\file
// C:\workspace\Tip\.\src\file
// C:\workspace\Tip\src\file
// ------默认绝对路径，取得路径相同-----
// C:\src\file
// C:\src\file
// C:\src\file
//
// 比较可以得到
// getPath()返回的是构造方法里的路径，不做任何处理
// getAbsolutePath()返回的是 user.dir+getPath()，也就是执行路径加上构造方法中的路径
// getCanonicalPath()返回的是将符号完全解析的路径，也就是全路径
}
}