JAVA提高篇（7）--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类的时候，必须设置好路径

示例：

[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类的方法，此类的常用方法如下所示：

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

创建方法

(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. }