java File相关操作

本文通过大量的示例，介绍和讲解了Java File操作。

1）创建文件  2）删除文件  3）判断文件是否存在  4）创建文件夹  5）文件类型判断  6）获取文件信息

7）获取目录下文件名  8）递归打印所有文件名  9）递归删除整个文件夹  10）Properties类

11）SequenceInputStream类：连接多个流  12）对象序列化实现Serializable接口  13）管道流

14）RandomAccessFile类   15）DataStream类  16)ByteArrayStream类

1、创建文件

1）boolean java.io.File.createNewFile() throws IOException用来创建文件，如果文件存在，创建失败，返回false；

2）new File("a.txt");并不创建文件实体，只是创建一个指向“a.txt”的引用。

3）路径分隔符：File.separator

[java]  view plain  copy

1. package file.dol.sn;  
2.   
3. import java.io.File;  
4.   
5. public class FileDemo {  
6.   
7.     public static void main(String[] args) {  
8.         //new File()就相当于是C语言中定义一个指向“a.txt”的文件指针  
9.         File f1 = new File("a.txt");  
10.         try   
11.         {  
12.             //创建文件:boolean java.io.File.createNewFile() throws IOException  
13.             boolean b = f1.createNewFile();  
14.             //第二次将会创建失败false，这里和流不一样  
15.             System.out.println(b);  
16.         }   
17.         catch (Exception e)   
18.         {  
19.             // TODO: handle exception  
20.         }  
21.         //目录分隔符：File.separator，相当于“\\”跨平台。  
22.         //File f2 = new File("E:\\tmp","b.txt");  
23.         File f2 = new File("E:"+File.separator+"tmp","b.txt");  
24.         System.out.println(f2);  
25.     }  
26. }  

2、删除文件

1）delete()：删除文件成功返回true，删除失败返回false（ boolean java.io.File.delete()  ）

2）deleteOnExit()：程序退出时，自动删除文件。一般用于对程序创建的临时文件进行操作，退出时删除。（ void java.io.File.deleteOnExit()  ）

[java]  view plain  copy

1. package file.dol.sn;  
2.   
3. import java.io.File;  
4.   
5. public class FileDemo {  
6.   
7.     public static void main(String[] args) {  
8.   
9.         File f1 = new File("a.txt");  
10.         try   
11.         {  
12.             boolean b = f1.createNewFile();  
13.             //删除文件：boolean java.io.File.delete()  
14.             f1.delete();  
15.             //程序退出时，自动删除：void java.io.File.deleteOnExit()  
16.             //f1.deleteOnExit();  
17.         }   
18.         catch (Exception e)   
19.         {  
20.             // TODO: handle exception  
21.         }  
22.     }  
23. }  

3、判断文件是否存在

exists()：判断文件是否存在（ boolean java.io.File.exists() ）

[java]  view plain  copy

1. package file.dol.sn;  
2.   
3. import java.io.File;  
4.   
5. public class FileDemo {  
6.   
7.     public static void main(String[] args) {  
8.   
9.         File f1 = new File("not.txt");  
10.         //判断文件是否存在：boolean java.io.File.exists()  
11.         boolean b = f1.exists();  
12.         System.out.println(b);  
13.     }  
14. }  

4、创建文件夹

1）mkdir()：只能创建“一级目录”（boolean java.io.File.mkdir()）；

2）mkdirs()：可以创建多级目录（boolean java.io.File.mkdirs()）。

[java]  view plain  copy

1. package file.dol.sn;  
2.   
3. import java.io.File;  
4.   
5. public class FileDemo {  
6.   
7.     public static void main(String[] args) {  
8.   
9.         File dir1 = new File("abc");  
10.         File dir2 = new File("a\\b\\c\\d");  
11.         try   
12.         {  
13.             //创建文件目录(即文件夹)：boolean java.io.File.mkdir()  
14.             //该方法只能创建“一级”目录  
15.             boolean b =  dir1.mkdir();  
16.             System.out.println(b);  
17.             //创建多级文件夹：boolean java.io.File.mkdirs()  
18.             b =  dir2.mkdirs();  
19.             System.out.println(b);  
20.         }   
21.         catch (Exception e)   
22.         {  
23.             System.out.println(e.toString());  
24.         }  
25.     }  
26. }  

5、文件类型判断

1）exists()：判断文件是否存在，注意：一定要先判断这个；

2）isDirectory()：判断是否为文件夹；

3）isFile()：判断是否为文件；

4）isHidden()：判断是否为隐藏文件；

5）isAbsolute()：判断是否为绝对路径，这里不管文件是否存在都能判断。

[java]  view plain  copy

1. package file.dol.sn;  
2.   
3. import java.io.File;  
4.   
5. public class FileDemo {  
6.   
7.     public static void main(String[] args) {  
8.   
9.         File f = new File("C:\\abc.txt");  
10.         try   
11.         {  
12.             //判断文件是否存在  
13.             if (f.exists())  
14.             {  
15.                 //判断文件是否是文件夹  
16.                 if (f.isDirectory())  
17.                 {  
18.                     System.out.println("文件夹");  
19.                 }  
20.                 //判断文件是否是文件  
21.                 if (f.isFile())  
22.                 {  
23.                     System.out.println("文件");  
24.                 }  
25.                 //判断是否为隐藏文件  
26.                 if (f.isHidden())  
27.                 {  
28.                     System.out.println("隐藏文件");  
29.                 }  
30.             }  
31.             else   
32.             {  
33.                 System.out.println("文件不存在");  
34.             }  
35.             //判断是否为绝对路径，不管文件是否存在  
36.             if (f.isAbsolute())  
37.             {  
38.                 System.out.println("是绝对路径");  
39.             }  
40.         }   
41.         catch (Exception e)   
42.         {  
43.             System.out.println(e.toString());  
44.         }  
45.     }  
46. }  

6、获取文件信息

1）getName()：获取文件名；

2）getParent()：获取文件父目录；

3）getPath()：获取文件路径；

4）getAbsolutePath()：获取文件绝对路径；

5）lastModified()：获得文件最后一次被修改的时间；

6）length()：获取文件大小；

7）renameTo()：文件剪切，将文件f1剪切然后粘贴到f2（相当于右键f1->剪切->粘贴->f2所在目录）

[java]  view plain  copy

1. package file.dol.sn;  
2.   
3. import java.io.File;  
4.   
5. public class FileDemo {  
6.   
7.     public static void main(String[] args) {  
8.   
9.         File f1 = new File("abc.txt");  
10.         File f2 = new File("E:\\Java\\test.txt");  
11.         try   
12.         {  
13.             //获得文件名  
14.             System.out.println(f1.getName());  
15.             //获得绝对路径中的父目录，如：File("abc.txt")则该返回为null  
16.             System.out.println(f1.getParent());  
17.             //获得相对路径  
18.             System.out.println(f1.getPath());  
19.             //获得绝对路径  
20.             System.out.println(f1.getAbsolutePath());  
21.             //获得文件最后一次被修改的时间  
22.             System.out.println(f1.lastModified());  
23.             //获得文件大小  
24.             System.out.println(f1.length());  
25.             //文件剪切，将文件f1剪切然后粘贴到f2（相当于右键f1->剪切->粘贴->f2所在目录）  
26.             f1.renameTo(f2);  
27.         }   
28.         catch (Exception e)   
29.         {  
30.             System.out.println(e.toString());  
31.         }  
32.     }  
33. }  

7、获取目录下文件名

1）listRoots()：获取系统盘符；

2）list()：获取“X:\\”目录下的所有文件名，包括隐藏文件和文件夹（调用list()方法时，必须先封装一个目录，且必须存在的目录。）

3）list(FilenameFilter filter)：列出文件名的时候，可以进行过滤操作（如：列出后缀名为.txt的文件）。

4）listFiles()：列出目录下文件名，不包括文件夹。

[java]  view plain  copy

1. package file.dol.sn;  
2.   
3. import java.io.File;  
4. import java.io.FilenameFilter;  
5.   
6. public class FileDemo {  
7.   
8.     public static void main(String[] args) {  
9.         //1.获得系统有效盘符  
10.         File[] files = File.listRoots();  
11.         for (File f : files)  
12.             System.out.println(f.toString());  
13.         System.out.println("——————————————————————");  
14.         //2.获得C:\\目录下的所有文件名，包括隐藏文件和文件夹  
15.         //调用list()方法时，必须先封装一个目录，且必须存在的目录。  
16.         File fnFile = new File("C:\\");  
17.         String[] strings = fnFile.list();  
18.         for (String s : strings)  
19.             System.out.println(s);  
20.         System.out.println("——————————————————————");  
21.         //3.调用list()方法，列出后缀名为.txt的文件  
22.         strings = fnFile.list(new FilenameFilter() {  
23.               
24.             @Override  
25.             public boolean accept(File dir, String name) {  
26.                 //找出后缀名为.txt的文件名  
27.                 return name.endsWith(".txt");  
28.             }  
29.         });  
30.         for (String s : strings)  
31.             System.out.println(s);  
32.         System.out.println("——————————————————————");  
33.         //4.获取C:\\目录下的文件夹，不包括文件夹  
34.         files = fnFile.listFiles();  
35.         for (File f : files)  
36.             System.out.println(f.toString());  
37.     }  
38. }  

8、递归打印所有文件名

注意：测试中，有些隐藏文件名不能访问还是其他的原因，当在打印根目录（如："C:\\"）下的所有文件名时，会有个叫“System Volume Information”的隐藏文件夹，访问失败，所以以下代码中，不访问隐藏文件。

[java]  view plain  copy

1. package file.dol.sn;  
2.   
3. import java.io.File;  
4.   
5. public class FileDemo {  
6.   
7.     public static void main(String[] args) {  
8.   
9.         File dirFile = new File("E:\\Dol");  
10.         showDir(dirFile,0);  
11.     }  
12.     public static void showDir(File dir,int level)  
13.     {  
14.         System.out.println(printSpace(level)+"文件夹："+dir.getName());  
15.         level += 4;  
16.         File[] file = dir.listFiles();  
17.         for (File f : file)  
18.         {  
19.             //递归进入所有非隐藏文件夹  
20.             if (f.isDirectory() && !f.isHidden())  
21.                 showDir(f,level);  
22.             //打印文件名  
23.             else  
24.                 System.out.println(printSpace(level)+f.getName());  
25.         }  
26.     }  
27.     //实现分层次打印，补充空格  
28.     public static StringBuffer printSpace(int level)  
29.     {  
30.         StringBuffer space = new StringBuffer();  
31.         for (int i = 0; i < level; ++i)  
32.         {  
33.             space.append("  ");  
34.         }  
35.         return space;  
36.     }  
37. }  

9、递归删除整个文件夹

[java]  view plain  copy

1. package file.dol.sn;  
2.   
3. import java.io.File;  
4.   
5. public class FileDemo {  
6.   
7.     public static void main(String[] args) {  
8.   
9.         File dirFile = new File("E:\\Dol");  
10.         deleteDir(dirFile,0);  
11.     }  
12.     public static void deleteDir(File dir,int level)  
13.     {  
14.         File[] file = dir.listFiles();  
15.         //循环递归删除文件夹里面的所有内容  
16.         for (File f : file)  
17.         {  
18.             //递归进入所有非隐藏文件夹  
19.             if (f.isDirectory() && !f.isHidden())  
20.                 deleteDir(f,level);  
21.             //删除文件  
22.             else  
23.             {  
24.                 f.delete();  
25.                 System.out.println(f.getName()+"——已删除");  
26.             }  
27.         }  
28.         //删除该文件夹  
29.         dir.delete();  
30.         System.out.println(dir.getName()+"——已删除");  
31.     }  
32. }  

10、Properties类

1）常用的基本操作，设置键值，获取值。

[java]  view plain  copy

1. package file.dol.sn;  
2.   
3. import java.util.Properties;  
4. import java.util.Set;  
5.   
6. public class FileDemo {  
7.   
8.     public static void main(String[] args) {  
9.         //Properties是HashTable的子类，里面存放的都是键值对的字符串  
10.         Properties prop = new Properties();  
11.         //设置键值  
12.         prop.setProperty("Dolphin", "海豚");  
13.         prop.setProperty("Dol", "CSDN");  
14.         //获取  
15.         String value = prop.getProperty("Dolphin");  
16.         System.out.println("@@@@value@@@@"+value);  
17.           
18.         //返回一个集合  
19.         Set<String> nameSet = prop.stringPropertyNames();  
20.         for (String s : nameSet)  
21.         {  
22.             System.out.println(s+":"+prop.getProperty(s));  
23.         }  
24.     }  
25. }  

2）读取配置文件

读取配置文件，并对配置文件进行修改，修改后再保存。

[java]  view plain  copy

1. package file.dol.sn;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileOutputStream;  
5. import java.io.IOException;  
6. import java.util.Properties;  
7.   
8. public class FileDemo {  
9.   
10.     public static void main(String[] args) throws IOException{  
11.   
12.         Properties prop = new Properties();  
13.         //Properties加载的文件必须为键值对，#注释的不会被加载  
14.         FileInputStream fis = new FileInputStream("pz.txt");  
15.         prop.load(fis);  
16.         //添加一个键值对  
17.         prop.setProperty("Dol", "123");  
18.         //对键值对进行修改  
19.         prop.setProperty("Dol", "321");  
20.         FileOutputStream fos = new FileOutputStream("pz.txt");  
21.         //保存配置文件  
22.         //void java.util.Properties.store(OutputStream arg0, String arg1) throws IOException  
23.         //第二个参数为注释，可写可不写，写入时会自动添加#  
24.         prop.store(fos, "comment");  
25.           
26.         prop.list(System.out);  
27.         fis.close();  
28.         fos.close();  
29.     }  
30. }  

11、SequenceInputStream类：连接多个流

说明：Enumeration（列举）
public interface Enumeration<E>实现 Enumeration 接口的对象，它生成一系列元素，一次生成一个。连续调用 nextElement 方法将返回一系列的连续元素。
例如，要输出 Vector<E> v 的所有元素，可使用以下方法：
for (Enumeration<E> e = v.elements(); e.hasMoreElements();)
System.out.println(e.nextElement());
这些方法主要通过向量的元素、哈希表的键以及哈希表中的值进行枚举。枚举也用于将输入流指定到 SequenceInputStream 中。
注：此接口的功能与 Iterator 接口的功能是重复的。此外，Iterator 接口添加了一个可选的移除操作，并使用较短的方法名。新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。
有两个方法：
hasMoreElements() 测试此枚举是否包含更多的元素。
nextElement() 如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

[java]  view plain  copy

1. package file.dol.sn;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileOutputStream;  
5. import java.io.IOException;  
6. import java.io.SequenceInputStream;  
7. import java.util.Enumeration;  
8. import java.util.Vector;  
9.   
10. public class FileDemo {  
11.   
12.     public static void main(String[] args) throws IOException {  
13.   
14.         //将多个流加入集合  
15.         Vector<FileInputStream> vector = new Vector<FileInputStream>();  
16.         vector.add(new FileInputStream("E:\\1.txt"));  
17.         vector.add(new FileInputStream("E:\\2.txt"));  
18.         vector.add(new FileInputStream("E:\\3.txt"));  
19.   
20.         //java.util.Enumeration<FileInputStream>用法见说明  
21.         Enumeration<FileInputStream> en = vector.elements();  
22.         //连接多个流  
23.         SequenceInputStream sis = new SequenceInputStream(en);  
24.         //启动输出流  
25.         FileOutputStream fos = new FileOutputStream("E:\\4.txt");  
26.         //开始文件拷贝  
27.         byte[] buf = new byte[1024];  
28.         int len = 0;  
29.         while ((len=sis.read(buf))!=-1)  
30.             fos.write(buf,0,len);  
31.         //关闭资源  
32.         fos.close();  
33.         sis.close();  
34.     }  
35. }  

12、对象序列化实现Serializable接口

1）添加序列号；

2）静态成员变量不可序列化；

3）堆内存变量要想不被序列化，可以加transient关键字。

[java]  view plain  copy

1. package file.dol.sn;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileOutputStream;  
5. import java.io.IOException;  
6. import java.io.ObjectInputStream;  
7. import java.io.ObjectOutputStream;  
8. import java.io.Serializable;  
9.   
10. //序列化，必须实现Serializable接口，该接口不需要覆盖方法  
11. class Person implements Serializable  
12. {  
13.     //记得添加序列化号  
14.     public static final long serialVersionUID = 42L;  
15.   
16.     //堆内存变量可序列化  
17.     private String name;  
18.     private int age;  
19.     //如果不想将堆内存里面的变量序列化，如下声明就可以了  
20.     //transient int age;  
21.     //注意，静态成员变量不可序列化  
22.     private static String sex = "male";  
23.     public Person(String n, int a, String s)  
24.     {  
25.         name = n;  
26.         age = a;  
27.         sex = s;  
28.     }  
29.     //覆盖toString()方便println()打印  
30.     public String toString()  
31.     {  
32.         return name+":"+age+":"+sex;  
33.     }  
34. }  
35. public class FileDemo {  
36.   
37.     public static void WriteOut() throws IOException  
38.     {  
39.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));  
40.         oos.writeObject(new Person("Dolphin", 20,"female"));  
41.         oos.close();  
42.     }  
43.     public static void ReadIn() throws Exception  
44.     {  
45.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));  
46.         Person p = (Person)ois.readObject();  
47.         ois.close();  
48.         System.out.println(p);  
49.     }  
50.     //这里直接抛出一个较大的异常Exception（IOException的基类）  
51.     public static void main(String[] args) throws Exception {  
52.         //注意：以下函数需要分两次运行，每次只运行一个，方便观察运行效果  
53.         //WriteOut();  
54.         ReadIn();  
55.     }  
56. }  

13、管道流

1）平时两个流读写都是通过内存变量，进行数据操作的；

2）这里引入管道流，开启两个线程，一个读取流，一个写入流，直接将两个流对接上。

[java]  view plain  copy

1. package io.dol.sn;  
2.   
3. import java.io.PipedInputStream;  
4. import java.io.PipedOutputStream;  
5. //实现Runnable方法，多线程  
6. class Read implements Runnable  
7. {  
8.     private PipedInputStream in;  
9.     public Read(PipedInputStream in)   
10.     {  
11.         this.in = in;  
12.     }  
13.     public void run()   
14.     {  
15.         try {  
16.             byte[] buf = new byte[1024];  
17.             int len = 0;  
18.             //如果流中无数据，read()进入等待状态  
19.             while ((len=in.read(buf))!=-1)  
20.             {  
21.                 System.out.println(buf);  
22.             }  
23.             in.close();  
24.         } catch (Exception e) {  
25.             throw new RuntimeException("管道流读取失败");  
26.         }  
27.     }  
28. }  
29.   
30. class Write implements Runnable  
31. {  
32.     private PipedOutputStream out;  
33.     public Write(PipedOutputStream in)   
34.     {  
35.         this.out = out;  
36.     }  
37.     public void run()   
38.     {  
39.         try {  
40.             out.write("Piped lai la...".getBytes());  
41.             out.close();  
42.         } catch (Exception e) {  
43.             throw new RuntimeException("管道流输出失败");  
44.         }     
45.     }  
46. }  
47.   
48. public class PipedStreamDemo {  
49.   
50.     public static void main(String[] args) {  
51.           
52.         PipedInputStream in = new PipedInputStream();  
53.         PipedOutputStream out = new PipedOutputStream();  
54.           
55.         Read r = new Read(in);  
56.         Write w = new Write(out);  
57.         //开启两线程  
58.         new Thread(r).start();  
59.         new Thread(w).start();  
60.     }  
61. }  

14、RandomAccessFile类

[java]  view plain  copy

1. package io.dol.sn;  
2.   
3. import java.io.IOException;  
4. import java.io.RandomAccessFile;  
5.   
6. public class RafDemo {  
7.   
8.     public static void Read() throws IOException  
9.     {  
10.         RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");  
11.         byte[] buf= new byte[4];  
12.         raf.read(buf);  
13.         String name = new String(buf);  
14.         int age;  
15.         age = raf.readInt();  
16.           
17.         raf.close();  
18.           
19.         System.out.println("网名："+name);  
20.         System.out.println("年龄："+age);  
21.     }  
22.     public static void Write() throws IOException  
23.     {  
24.         RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");  
25.         raf.write("海豚".getBytes());  
26.         raf.writeInt(20);  
27.         raf.close();  
28.     }  
29.     public static void main(String[] args) throws IOException {  
30.           
31.         Write();  
32.         Read();  
33.         //调整指针位置  
34.         //raf.seek(pos);  
35.         //跳过字节数  
36.         //raf.skipBytes(n);  
37.     }  
38. }  

15、DataStream类

[java]  view plain  copy

1. package io.dol.sn;  
2.   
3. import java.io.DataInputStream;  
4. import java.io.DataOutputStream;  
5. import java.io.FileInputStream;  
6. import java.io.FileOutputStream;  
7. import java.io.IOException;  
8.   
9. public class DataStreamDemo {  
10.   
11.     public static void main(String[] args) throws IOException {  
12.         //写数据  
13.         DataOutputStream out = new DataOutputStream(new FileOutputStream("data.txt"));  
14.           
15.         out.writeInt(123);  
16.         out.writeDouble(56.88);  
17.         out.writeBoolean(true);  
18.         out.close();  
19.         //读数据  
20.         DataInputStream in = new DataInputStream(new FileInputStream("data.txt"));  
21.         int nInt = in.readInt();  
22.         double nDou = in.readDouble();  
23.         boolean b = in.readBoolean();  
24.         in.close();  
25.         //显示  
26.         System.out.println("nInt:"+nInt);  
27.         System.out.println("nDou:"+nDou);  
28.         System.out.println("b:"+b);  
29.     }  
30. }  

16、ByteArrayStream类

[java]  view plain  copy

1. package io.dol.sn;  
2.   
3. import java.io.ByteArrayInputStream;  
4. import java.io.ByteArrayOutputStream;  
5.   
6. import javax.print.attribute.standard.Sides;  
7.   
8. public class ByteArrayStreamDemo {  
9.   
10.     public static void main(String[] args) {  
11.   
12.         ByteArrayInputStream in = new ByteArrayInputStream("Dolphin".getBytes());  
13.         ByteArrayOutputStream out = new ByteArrayOutputStream();  
14.           
15.         int len = 0;  
16.         // int java.io.ByteArrayInputStream.read() 从此输入流中读取下一个数据字节  
17.         while ((len=in.read())!=-1)  
18.         {  
19.             out.write(len);  
20.         }  
21.         System.out.println(out.size());  
22.     }  
23. }