您的位置: 首页  >  文章  >  JAVA提高篇（7）--File类对象及常用操作方法

JAVA提高篇（7）--File类对象及常用操作方法

分类: 文章 • 2025-04-09 13:49:28

版权声明：本文为博主原创文章，未经博主允许不得转载。

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

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类的时候，必须设置好路径

示例：

[java] view plain copy
  1. import java.io.File;  
  2. public class FileDemo {  
  3.     public static void main(String[] args) {  
  4.         // 构造函数File(String pathname)  
  5.         File f1 = new File("d:\\daxiang\\1.txt");  
  6.         // File(String parent,String child)  
  7.         File f2 = new File("d:\\daxiang", "2.txt");  
  8.         // File(File parent,String child)  
  9.         File f3 = new File("d:" + File.separator + "abc");// separator 跨平台分隔符  
  10.         File f4 = new File(f3, "3.txt");  
  11.         System.out.println(f1);// d:\daxiang\1.txt  
  12.         System.out.println(f2);// d:\daxiang\2.txt  
  13.         System.out.println(f3);// d:\abc  
  14.         System.out.println(f4);// d:\abc\3.txt  
  15.     }  
  16. }  

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

2.文件对象操作方法

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


JAVA提高篇（7）--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)

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

[java] view plain copy
  1. import java.io.File;  
  2.   
  3. public class FileExercise {  
  4.     public static void main(String[] args) throws Exception {  
  5.   
  6.         System.out.println("当前操作系统的名称分隔符是：" + java.io.File.separator);  
  7.         System.out.println("当前操作系统的路径分隔符是：" + java.io.File.pathSeparator);  
  8.         // 字符串类型的文件名  
  9.         String fileName = "daxiang.txt";  
  10.         // 实例化文件对象  
  11.         File file = new File("src", fileName);  
  12.         File file1 = new File("D:\\daxiang\\testjava\\src\\txt");  
  13.         File file2 = new File("D:\\daxiang\\testjava\\src");  
  14.         // 创建一个文件  
  15.         file.createNewFile(); //注意file是抽象路径，此时会在当前java工程下的src文件夹下创建一个daxiang.txt文件  
  16.   
  17.         boolean b;// 申明一个boolean类型的变量  
  18.   
  19.         // 测试应用程序是否可以执行该文件  
  20.         b = file.canExecute();  
  21.         System.out.println("测试应用程序是否可以执行该文件" + b);  
  22.   
  23.         // 测试用用程序是否可以读取该文件  
  24.         b = file.canRead();  
  25.         System.out.println("测试用用程序是否可以读取该文件" + b);  
  26.   
  27.         // 测试用用程序是否可以修改该文件  
  28.         b = file.canWrite();  
  29.         System.out.println("测试用用程序是否可以修改该文件" + b);  
  30.   
  31.         // 测试此抽象路径名表示的文件或目录是否存在。  
  32.         b = file.exists();  
  33.         System.out.println("测试此抽象路径名表示的文件或目录是否存在" + b);  
  34.   
  35.         // 按字母顺序比较两个抽象路径名  
  36.         int i = file.compareTo(file1); //compareTo方法，返回参与比较的前后两个字符串的ASCII码的差值  
  37.         System.out.println(i);  
  38.   
  39.         String path;  
  40.         // 返回此抽象路径名的绝对路径名字符串  
  41.         path = file.getAbsolutePath();  
  42.         System.out.println(path);  
  43.   
  44.         // 返回此抽象路径名的规范路径名字符串  
  45.         path = file.getCanonicalPath();  
  46.         System.out.println(path);  
  47.   
  48.         long free;  
  49.         // 返回此抽象路径名指定的分区中未分配的字节数  
  50.         free = file.getFreeSpace();  
  51.         System.out.println("此抽象路径名指定的分区中未分配的字节数" + free);  
  52.   
  53.         // 返回由此抽象路径名表示的文件或目录的名称  
  54.         String name;  
  55.         name = file.getName();  
  56.         System.out.println(name);  
  57.         name = file1.getName();  
  58.         System.out.println(name);  
  59.   
  60.         // 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null  
  61.         String parentpath;  
  62.         parentpath = file.getParent();  
  63.         System.out.println(parentpath);  
  64.         parentpath = file1.getParent();  
  65.         System.out.println(parentpath);  
  66.   
  67.         // 返回此抽象路径名指定的分区上可用于此虚拟机的字节数  
  68.         free = file.getUsableSpace();  
  69.         System.out.println("此抽象路径名指定的分区上可用于此虚拟机的字节数" + free);  
  70.   
  71.         // 计算此抽象路径名的哈希码  
  72.         i = file.hashCode();  
  73.         System.out.println(i);  
  74.   
  75.         // 测试此抽象路径名是否为绝对路径名  
  76.         b = file.isAbsolute();  
  77.         System.out.println("file对象的抽象路径名是否为绝对路径名：" + b);  
  78.         b = file1.isAbsolute();  
  79.         System.out.println("file1对象的抽象路径名是否为绝对路径名：" + b);  
  80.   
  81.         // 返回此抽象路径名表示的文件最后一次被修改的时间  
  82.         long time = file.lastModified();  
  83.         System.out.println(time);  
  84.   
  85.         // 返回由此抽象路径名表示的文件的长度  
  86.         long length = file.length();  
  87.         System.out.println("文件的长度:" + length);  
  88.         System.out.println();  
  89.           
  90.         // 注意list()和listFile()的区别  
  91.         // list()-->返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录  
  92.         String[] array1 = file2.list();  
  93.         for (i = 0; i < array1.length; i++) {  
  94.             System.out.println(array1[i]);  
  95.         }  
  96.         System.out.println();  
  97.           
  98.         // listFiles()-->返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件  
  99.         File[] array2 = file2.listFiles();  
  100.         for (i = 0; i < array2.length; i++) {  
  101.             System.out.println(array2[i]);  
  102.         }  
  103.         System.out.println();  
  104.           
  105.         // listRoots()-->列出可用的文件系统根,静态方法  
  106.         File[] roots = File.listRoots();  
  107.         for (i = 0; i < roots.length; i++) {  
  108.             System.out.println(roots[i]);  
  109.         }  
  110.         System.out.println();  
  111.           
  112.         // 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。  
  113.         // file.deleteOnExit();  
  114.   
  115.         // 创建此抽象路径名指定的目录  
  116.         file1.mkdir();  
  117.         // 重新命名此抽象路径名表示的文件  
  118.         File file4 = new File("src\\重命名文件");  
  119.         System.out.println(file1.renameTo(file4));  
  120.         // 设置文件只读  
  121.         file.setReadOnly();  
  122.         // 设置文件可写  
  123.         file.setWritable(true);  
  124.     }  
  125. }  

三、File类常用操作实例

[java] view plain copy
  1. <span style="font-size:14px;">/** 
  2.  * 实例操作一：创建一个新文件 
  3.  * 在D盘创建一个test.txt文件 
  4.  */  
  5. import java.io.File;  
  6. import java.io.IOException;  
  7.   
  8. public class FileOperate {  
  9.     public static void main(String[] args) {  
  10.         File f = new File("d:" + File.separator + "test.txt");// 为增加可移植性，建议使用File.separator  
  11.         try {  
  12.             f.createNewFile();  
  13.         } catch (IOException e) {  
  14.             e.printStackTrace();  
  15.         }  
  16.     }  
  17. }  
  18.   
  19. /** 
  20.  * 实例操作二：删除一个指定文件 
  21.  * 删除刚刚在D盘创建的test.txt文件 
  22.  */  
  23. import java.io.File;  
  24.   
  25. public class FileOperate {  
  26.     public static void main(String[] args) {  
  27.         File f = new File("d:" + File.separator + "test.txt");  
  28.         if (f.exists()) {// 判断文件存不存在，如不存在就不用删除了  
  29.             f.delete();  
  30.         }  
  31.     }  
  32. }  
  33.   
  34. /** 
  35.  * 实例操作三：综合创建、删除文件的操作 
  36.  * 给定一个路径，如果此文件存在，则删除，如果不存在，则创建 
  37.  */  
  38. import java.io.File;  
  39. import java.io.IOException;  
  40.   
  41. public class FileOperate {  
  42.     public static void main(String[] args) {  
  43.         File f = new File("d:" + File.separator + "test.txt");  
  44.         if (f.exists()) {  
  45.             f.delete();  
  46.         } else {  
  47.             try {  
  48.                 f.createNewFile();  
  49.             } catch (IOException e) {  
  50.                 e.printStackTrace();  
  51.             }  
  52.         }  
  53.     }  
  54. }  
  55.   
  56. /** 
  57.  * 实例操作四：创建一个文件夹 
  58.  * 使用mkdir()方法创建一个文件夹 
  59.  */  
  60. import java.io.File;  
  61.   
  62. public class FileOperate {  
  63.     public static void main(String[] args) {  
  64.         File f = new File("d:" + File.separator + "test");  
  65.         f.mkdir();// 创建文件夹  
  66.     }  
  67. }  
  68.   
  69. /** 
  70.  * 实例操作五：列出指定目录的全部文件 
  71.  * 如果现在给出了一个目录，则可以直接列出目录中的内容。但是列出的方法在File类中存在两个： 
  72.  * 以字符串数组的形式返回：public String[] list() 
  73.  * 以File数组的形式返回：public File[] listFiles() 
  74.  */  
  75. /** 
  76. * 实例操作五：列出指定目录的全部文件 
  77.  * 操作一：使用list()列出全部内容 
  78.  * 该方法列出了D盘下的文件夹和文件的名字 
  79.  */  
  80. import java.io.File;  
  81.   
  82. public class FileOperate {  
  83.     public static void main(String[] args) {  
  84.         File f = new File("d:" + File.separator);  
  85.         String[] str = f.list();  
  86.         for (String s : str) {  
  87.             System.out.println(s);  
  88.         }  
  89.     }  
  90. }  
  91.   
  92. /** 
  93.  * 实例操作五：列出指定目录的全部文件 
  94.  * 操作二：使用listFiles()列出 
  95.  * 列出了完全路径 
  96.  */  
  97. import java.io.File;  
  98.   
  99. public class FileOperate {  
  100.     public static void main(String[] args) {  
  101.         File f = new File("d:" + File.separator);  
  102.         File[] files = f.listFiles();  
  103.         for (File file : files) {  
  104.             System.out.println(file);  
  105.         }  
  106.     }  
  107. }  
  108.   
  109. /** 
  110.  * 实例操作六：判断一个给定的路径是否目录 
  111.  * 给定路径，判断是否是目录 
  112.  */  
  113. import java.io.File;  
  114.   
  115. public class FileOperate {  
  116.     public static void main(String[] args) {  
  117.         File f = new File("d:" + File.separator);  
  118.         if (f.isDirectory()) {  
  119.             System.out.println(f.getPath() + "是目录");  
  120.         } else {  
  121.             System.out.println(f.getPath() + "不是目录");  
  122.         }  
  123.     }  
  124. }  
  125.   
  126. /** 
  127.  * 实例操作七：列出指定目录的全部内容(递归) 
  128.  * 如果给定了一个目录，则要求把此目录中的全部文件都列出来，包括子文件夹下的文件 
  129.  */  
  130. import java.io.File;  
  131. public class FileOperate {  
  132.     public static void main(String[] args) {  
  133.         File f = new File("d:" + File.separator);  
  134.         print(f);  
  135.     }  
  136.   
  137.     public static void print(File f) {  
  138.         if (f != null) {  
  139.             if (f.isDirectory()) {  
  140.                 File[] files = f.listFiles();  
  141.                 if (files != null) {  
  142.                     for (File file : files) {  
  143.                         print(file);  
  144.                     }  
  145.                 }  
  146.             } else {  
  147.                 System.out.println(f);  
  148.             }  
  149.         }  
  150.     }  
  151. }  
  152.   
  153. /** 
  154.  * 实例操作八：列出磁盘下的路径名 
  155.  * @param public static File[] listRoots() 
  156.  * @return 该方法返回指示可用的文件系统的根文件对象的数组。如果不能确定该组的根该方法返回null。 
  157.  */  
  158. import java.io.File;  
  159. public class FileDemo {  
  160.     public static void main(String[] args) {  
  161.   
  162.         File[] paths;  
  163.   
  164.         try {  
  165.             // returns pathnames for files and directory  
  166.             paths = File.listRoots();  
  167.   
  168.             // for each pathname in pathname array  
  169.             for (File path : paths) {  
  170.                 // prints file and directory paths  
  171.                 System.out.println(path);  
  172.             }  
  173.         } catch (Exception e) {  
  174.             // if any error occurs  
  175.             e.printStackTrace();  
  176.         }  
  177.     }  
  178. }  
  179.   
  180. /** 
  181.  * 实例操作九：列出磁盘下的文件和文件夹 
  182.  * @param public static File[] listRoots() 
  183.  * @return 该方法返回指示可用的文件系统的根文件对象的数组。如果不能确定该组的根该方法返回null。 
  184.  */  
  185. import java.io.File;  
  186.   
  187. public class FileDemo {  
  188.     public static void main(String[] args) {  
  189.           
  190.         File[] files = File.listRoots();  
  191.         for (File file : files) {  
  192.             System.out.println(file);  
  193.             if (file.length() > 0) {  
  194.                 String[] filenames = file.list();  
  195.                 for (String filename : filenames) {  
  196.                     System.out.println(filename);  
  197.                 }  
  198.             }  
  199.         }  
  200.     }  
  201. }  
  202.   
  203. /** 
  204.  * 实例操作十：文件过滤 
  205.  * @param FilenameFilter类 
  206.  * @return  
  207.  */  
  208. import java.io.File;  
  209. import java.io.FilenameFilter;  
  210. import java.io.IOException;  
  211.   
  212. public class FileDemo {  
  213.     public static void main(String[] args) throws IOException {  
  214.   
  215.         File dir = new File("d:\\daxiang\\testjava");  
  216.   
  217.         File[] files = dir.listFiles(new FilenameFilter() {  
  218.             // 获取.java文件时使用listFiles(FilenameFilter filter)方法，创建一个过滤文件名的Filter  
  219.             public boolean accept(File dir, String name) {  
  220.                 if (name != null && "".equals("")) {  
  221.                     // 检测文件名是否是以.saz结尾，是返回true，否则继续检测下一个文件  
  222.                     if (name.toLowerCase().endsWith(".java")) {  
  223.                         return true;  
  224.                     }  
  225.                 }  
  226.                 return false;  
  227.             }  
  228.         });  
  229.   
  230.         for (File file : files) {  
  231.             System.out.println(file);  
  232.         }  
  233.     }  
  234. }</span>  

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

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

[java] view plain copy
  1. import java.io.File;  
  2. import java.io.IOException;  
  3.   
  4. public class getFilePath {  
  5.     public static void main(String[] args) throws IOException {  
  6.         System.out.println("------默认相对路径，取得路径不同-----");  
  7.         File f = new File("..\\src\\file");  
  8.         System.out.println(f.getPath());  
  9.         System.out.println(f.getAbsolutePath());  
  10.         System.out.println(f.getCanonicalPath());  
  11.         System.out.println("------默认相对路径，取得路径不同-----");  
  12.         File f2 = new File(".\\src\\file");  
  13.         System.out.println(f2.getPath());  
  14.         System.out.println(f2.getAbsolutePath());  
  15.         System.out.println(f2.getCanonicalPath());  
  16.         System.out.println("------默认绝对路径，取得路径相同-----");  
  17.         File f3 = new File("C:\\src\\file");  
  18.         System.out.println(f3.getPath());  
  19.         System.out.println(f3.getAbsolutePath());  
  20.         System.out.println(f3.getCanonicalPath());  
  21.   
  22.         // 执行结果为：  
  23.         // ------默认相对路径，取得路径不同-----  
  24.         // ..\src\file  
  25.         // C:\workspace\Tip\..\src\file  
  26.         // C:\workspace\src\file  
  27.         // ------默认相对路径，取得路径不同-----  
  28.         // .\src\file  
  29.         // C:\workspace\Tip\.\src\file  
  30.         // C:\workspace\Tip\src\file  
  31.         // ------默认绝对路径，取得路径相同-----  
  32.         // C:\src\file  
  33.         // C:\src\file  
  34.         // C:\src\file  
  35.         //  
  36.         // 比较可以得到  
  37.         // getPath()返回的是构造方法里的路径，不做任何处理  
  38.         // getAbsolutePath()返回的是 user.dir+getPath()，也就是执行路径加上构造方法中的路径  
  39.         // getCanonicalPath()返回的是将符号完全解析的路径，也就是全路径  
  40.     }  
  41. }  

相关推荐