File类操做

File类的增删改查介绍

                 

[java] view plain copy print ?

1. package com.io.file;  
2.   
3. import java.io.File;  
4. import java.io.IOException;  
5.   
6. public class File_1 {  
7.     public static void main(String[] args) throws IOException, InterruptedException {  
8.         //mehtod_file();//File类的几种建立方式   
9.         //file_create();//建立文件   
10.         //file_delete();//删除文件   
11.         //file_judge();//判断文件   
12.         //file_get();//获取File封装对象内容   
13.         file_renameTo();  
14.     }  
15.     /* 
16.      * 修改文件名称 
17.      * 剪切文件，并粘贴文件 
18.      */  
19.     public static void file_renameTo(){  
20.         //实现文件剪切功能   
21. //      File f=new File("g:/java/aa.txt");   
22. //      File ff=new File("d:/bbb.txt");//注意：这里不能带文件夹;f封装的路径中的文件会被删除，ff封装的路径中的文件会被建立   
23. //      System.out.println(f.renameTo(ff));   
24.         //文件更名   
25.         File f1=new File("g:/java/aa.txt");  
26.         File f2=new File("g:/java/bb.txt");//注意：这里不能带文件夹;f封装的路径中的文件会被删除，ff封装的路径中的文件会被建立   
27.         System.out.println(f1.renameTo(f2));  
28.     }  
29.       
30.     /* 
31.      * 获取文件信息 
32.      */  
33.     public static void file_get(){  
34.         File f=new File("g:/java/yes.txt");  
35.         System.out.println("getPath():"+f.getPath());//无论该文件是否存在，就是获取File对象封装的路径内容   
36.         System.out.println("getAbsolute()"+f.getAbsolutePath());//无论该文件是否存在，获取File对象封装的绝对路径   
37.         System.out.println("getName():"+f.getName());//获取File对象封装的文件名称,包括后缀名   
38.         System.out.println("getParent():"+f.getParent());//获取File对象封装的文件夹路径名，注意，该方法获取的文件夹路径是File对象封装的绝对路径才能获取的，若是File对象封装的是相对路径的话，则返回null；   
39.                                                         //若是File对象封装的路径有上一层目录，则返回的目录就是该目录如：File f=new file("a\\b.txt");则返回a目录   
40.         System.out.println("lastModified():"+f.lastModified());//获取File对象封装的文件最后一次修改的时间   
41.         System.out.println("length():"+f.length());//获取File对象封装的文件的大小，即多少个字节   
42.     }  
43.     /* 
44.      * 判断文件 
45.      *  
46.      */  
47.     public static void file_judge(){  
48.         File f=new File("g:/java/yes.txt");  
49.         System.out.println(f.canExecute());//判断文件是否可执行   
50.         System.out.println(f.exists());//判断文件是否存在   
51.         System.out.println("-----------------------------------------");  
52.         File ff=new File("g:/java/a/b/c/d/e/f");  
53. //      System.out.println(ff.mkdir());//建立文件夹   
54.         System.out.println(ff.mkdirs());//建立多级文件夹   
55.         System.out.println("------------------------------------------");  
56.         File fff=new File("zzzz.txt");  
57.         //注意在判断是不是文件和目录时，必定要先判断该文件对象封装的内容是否存在   
58.         //用exists();判断   
59.         System.out.println(fff.isDirectory());//判断是不是目录   
60.         System.out.println(fff.isFile());//判断是不是文件   
61.         System.out.println(fff.isHidden());//判断文件是否隐藏   
62.         System.out.println(fff.isAbsolute());//判断文件路径是不是绝对路径，及时文件不存在也能够判断   
63.     }  
64.     /* 
65.      *删除文件 
66.      * boolean  delete();删除失败是返回false 
67.      * void     deleteOnExit();当虚拟机退出时删除文件 
68.      */  
69.     public static void file_delete() throws IOException, InterruptedException{  
70.         File f=new File("g:/java/yesaaa.txt");  
71.         boolean boo=f.createNewFile();  
72.         System.out.println("create:"+boo);  
73.         Thread.sleep(5000);//能够看到效果   
74.         //boolean boo1=f.delete();   
75.         f.deleteOnExit();//通常删除临时文件时用这个，当虚拟机关闭时，删除文件   
76.         //System.out.println("delete:"+boo1);   
77.     }  
78.     /* 
79.      * 建立文件createNewFile()，建立指定目录的文件，若是已存在，则返回false 
80.      * 注意：这和输出流不同，输出流对象建立文件，若是文件已存在，则会覆盖，重新建立 
81.      */  
82.     public static void file_create() throws IOException{  
83.         File f=new File("g:/java/yesaaa.txt");  
84.         boolean boo=f.createNewFile();  
85.         System.out.println(boo);  
86.     }  
87.     //几种建立File类的方式   
88.     public static void mehtod_file(){  
89.         File f1=new File("aa.txt");//用相对路径   
90.         File f2=new File("c:\\aa\\bb\\c.txt");//用绝对路径   
91.         File f3=new File("c:\\aa\\bb","c.txt");//文件夹路径和文件路径分开，便于操做   
92.         File f4=new File("c:/aa/bb/c.txt");//注意用这个斜杠"/"一个就好了，和"\\"两个这样的效果是同样的，但这样写不利于跨平台   
93.         File f5=new File("c:"+File.separator+"aa"+File.separator+"bb"+File.separator+"c.txt");//用File类中封装的separator()方法，能够实现跨平台   
94.         System.out.println(f1);  
95.         System.out.println(f2);  
96.         System.out.println(f3);  
97.         System.out.println(f4);  
98.         System.out.println(f5);  
99.     }  
100. }  

package com.io.file;

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

public class File_1 {
	public static void main(String[] args) throws IOException, InterruptedException {
		//mehtod_file();//File类的几种建立方式
		//file_create();//建立文件
		//file_delete();//删除文件
		//file_judge();//判断文件
		//file_get();//获取File封装对象内容
		file_renameTo();
	}
	/*
	 * 修改文件名称
	 * 剪切文件，并粘贴文件
	 */
	public static void file_renameTo(){
		//实现文件剪切功能
//		File f=new File("g:/java/aa.txt");
//		File ff=new File("d:/bbb.txt");//注意：这里不能带文件夹;f封装的路径中的文件会被删除，ff封装的路径中的文件会被建立
//		System.out.println(f.renameTo(ff));
		//文件更名
		File f1=new File("g:/java/aa.txt");
		File f2=new File("g:/java/bb.txt");//注意：这里不能带文件夹;f封装的路径中的文件会被删除，ff封装的路径中的文件会被建立
		System.out.println(f1.renameTo(f2));
	}
	
	/*
	 * 获取文件信息
	 */
	public static void file_get(){
		File f=new File("g:/java/yes.txt");
		System.out.println("getPath():"+f.getPath());//无论该文件是否存在，就是获取File对象封装的路径内容
		System.out.println("getAbsolute()"+f.getAbsolutePath());//无论该文件是否存在，获取File对象封装的绝对路径
		System.out.println("getName():"+f.getName());//获取File对象封装的文件名称,包括后缀名
		System.out.println("getParent():"+f.getParent());//获取File对象封装的文件夹路径名，注意，该方法获取的文件夹路径是File对象封装的绝对路径才能获取的，若是File对象封装的是相对路径的话，则返回null；
														//若是File对象封装的路径有上一层目录，则返回的目录就是该目录如：File f=new file("a\\b.txt");则返回a目录
		System.out.println("lastModified():"+f.lastModified());//获取File对象封装的文件最后一次修改的时间
		System.out.println("length():"+f.length());//获取File对象封装的文件的大小，即多少个字节
	}
	/*
	 * 判断文件
	 * 
	 */
	public static void file_judge(){
		File f=new File("g:/java/yes.txt");
		System.out.println(f.canExecute());//判断文件是否可执行
		System.out.println(f.exists());//判断文件是否存在
		System.out.println("-----------------------------------------");
		File ff=new File("g:/java/a/b/c/d/e/f");
//		System.out.println(ff.mkdir());//建立文件夹
		System.out.println(ff.mkdirs());//建立多级文件夹
		System.out.println("------------------------------------------");
		File fff=new File("zzzz.txt");
		//注意在判断是不是文件和目录时，必定要先判断该文件对象封装的内容是否存在
		//用exists();判断
		System.out.println(fff.isDirectory());//判断是不是目录
		System.out.println(fff.isFile());//判断是不是文件
		System.out.println(fff.isHidden());//判断文件是否隐藏
		System.out.println(fff.isAbsolute());//判断文件路径是不是绝对路径，及时文件不存在也能够判断
	}
	/*
	 *删除文件
	 * boolean 	delete();删除失败是返回false
	 * void 	deleteOnExit();当虚拟机退出时删除文件
	 */
	public static void file_delete() throws IOException, InterruptedException{
		File f=new File("g:/java/yesaaa.txt");
		boolean boo=f.createNewFile();
		System.out.println("create:"+boo);
		Thread.sleep(5000);//能够看到效果
		//boolean boo1=f.delete();
		f.deleteOnExit();//通常删除临时文件时用这个，当虚拟机关闭时，删除文件
		//System.out.println("delete:"+boo1);
	}
	/*
	 * 建立文件createNewFile()，建立指定目录的文件，若是已存在，则返回false
	 * 注意：这和输出流不同，输出流对象建立文件，若是文件已存在，则会覆盖，重新建立
	 */
	public static void file_create() throws IOException{
		File f=new File("g:/java/yesaaa.txt");
		boolean boo=f.createNewFile();
		System.out.println(boo);
	}
	//几种建立File类的方式
	public static void mehtod_file(){
		File f1=new File("aa.txt");//用相对路径
		File f2=new File("c:\\aa\\bb\\c.txt");//用绝对路径
		File f3=new File("c:\\aa\\bb","c.txt");//文件夹路径和文件路径分开，便于操做
		File f4=new File("c:/aa/bb/c.txt");//注意用这个斜杠"/"一个就好了，和"\\"两个这样的效果是同样的，但这样写不利于跨平台
		File f5=new File("c:"+File.separator+"aa"+File.separator+"bb"+File.separator+"c.txt");//用File类中封装的separator()方法，能够实现跨平台
		System.out.println(f1);
		System.out.println(f2);
		System.out.println(f3);
		System.out.println(f4);
		System.out.println(f5);
	}
}

                                       

【有奖提问】CSDN论坛第1期专家问答开始        来极客头条，赢下载积分        下载频道3月领任务~赚下载分！

 list()返回该目录下文件，文件夹,listFiles()返回文件文，件夹对象，递归调用获取全部文件，文件夹，以及文件名过滤  package com.io.file;  

1.   
2. import java.io.File;  
3. import java.io.FilenameFilter;  
4.   
5. public class File_listRoots {  
6.     public static void main(String[] args) {  
7.         //listRoots();//列出全部有效盘符   
8.         //list();//列出根文件下全部文件，文件夹，及隐藏文件   
9. //      listFilter();//文件名过滤   
10. //      listFiles();//获取当前目录下File对象   
11.         File f=new File("g:/");  
12. //      digui(f);//递归调用，实现查询目录下全部的文件及文件夹，及文件夹中的文件   
13.         System.out.println(digui1(8000));//递归调用   
14.     }  
15.     /* 
16.      * 递归调用注意两点： 
17.      * 1：限定条件 
18.      * 2：要注意递归次数，尽可能避免内存溢出 
19.      */  
20.     public static int digui1(int a){  
21.         if(a<=1){  
22.             return 1;  
23.         }else{  
24.             return a+digui1(a-1);  
25.         }  
26.     }  
27.     /* 
28.      * 列出指定目录下文件或文件夹，包含子目录中的内容，遍历目录下全部的文件。 
29.      * 由于目录中还有目录，只要使用同一个列出目录功能的函数完成便可 
30.      * 在列出过程当中，出现的仍是目录的话，还能够再次调用本功能。也就是函数自身调用自身。 
31.      * 这种表现形式或者变成手法成为递归 
32.      */  
33.     public static void digui(File f){  
34.         System.out.println(f.getAbsolutePath());  
35.         File[]ff=f.listFiles();  
36.         for (int i = 0; i < ff.length; i++) {  
37.             if(ff[i].isDirectory()){  
38.                 digui(ff[i]);//递归调用   
39.             }else{  
40.                 System.out.println(ff[i]);  
41.             }  
42.         }  
43.     }  
44.     /* 
45.      * listFiles();获取File对象 
46.      */  
47.     public static void listFiles(){  
48.         File f=new File("g:/java");  
49.         File[]ff=f.listFiles();  
50.         for(File fff:ff){  
51.             System.out.println(fff.getName()+"---------length:"+fff.length());  
52.         }  
53.     }  
54.     /* 
55.      * list(FileNameFilter filter),文件名过滤 
56.      */  
57.     public static void listFilter(){  
58.         File f=new File("g:/java");  
59.         String[]str=f.list(new FilenameFilter(){  
60.             public boolean accept(File f,String name){  
61.                   
62.                 return name.endsWith(".txt");//返回文件及文件夹名称以“.txt”为结尾的文件及文件夹   
63. //              System.out.println(f+"---------name:"+name);//f表明文件目录，name表明文件夹名称及文件名称   
64. //              return false;//返回false表示不返回   
65. //              return true;//返回true表示返回   
66.             }  
67.         });  
68.         for(String string:str){  
69.             System.out.println(string);  
70.         }  
71.     }  
72.     /* 
73.      * //列出根文件下全部文件，文件夹，及隐藏文件 
74.      */  
75.     public static void list(){  
76.         File f=new File("g:/java");//调用list()方法，该File对象必须封装一个目录，不能是文件,而且该目录确实存在才行   
77.         String[] str=f.list();  
78.         for (String string : str) {  
79.             System.out.println(string);  
80.         }  
81.     }  
82.     /* 
83.      * File.listRoots():获取可用的文件系统根，简单来讲就是获取系统的盘符 
84.      */  
85.     public static void listRoots(){  
86.         File[] f=File.listRoots();  
87.         for (File file : f) {  
88.             System.out.println(file);  
89.         }  
90.         System.out.println(f[0]);  
91.           
92.     }  
93. }  

package com.io.file;

import java.io.File;
import java.io.FilenameFilter;

public class File_listRoots {
	public static void main(String[] args) {
		//listRoots();//列出全部有效盘符
		//list();//列出根文件下全部文件，文件夹，及隐藏文件
//		listFilter();//文件名过滤
//		listFiles();//获取当前目录下File对象
		File f=new File("g:/");
//		digui(f);//递归调用，实现查询目录下全部的文件及文件夹，及文件夹中的文件
		System.out.println(digui1(8000));//递归调用
	}
	/*
	 * 递归调用注意两点：
	 * 1：限定条件
	 * 2：要注意递归次数，尽可能避免内存溢出
	 */
	public static int digui1(int a){
		if(a<=1){
			return 1;
		}else{
			return a+digui1(a-1);
		}
	}
	/*
	 * 列出指定目录下文件或文件夹，包含子目录中的内容，遍历目录下全部的文件。
	 * 由于目录中还有目录，只要使用同一个列出目录功能的函数完成便可
	 * 在列出过程当中，出现的仍是目录的话，还能够再次调用本功能。也就是函数自身调用自身。
	 * 这种表现形式或者变成手法成为递归
	 */
	public static void digui(File f){
		System.out.println(f.getAbsolutePath());
		File[]ff=f.listFiles();
		for (int i = 0; i < ff.length; i++) {
			if(ff[i].isDirectory()){
				digui(ff[i]);//递归调用
			}else{
				System.out.println(ff[i]);
			}
		}
	}
	/*
	 * listFiles();获取File对象
	 */
	public static void listFiles(){
		File f=new File("g:/java");
		File[]ff=f.listFiles();
		for(File fff:ff){
			System.out.println(fff.getName()+"---------length:"+fff.length());
		}
	}
	/*
	 * list(FileNameFilter filter),文件名过滤
	 */
	public static void listFilter(){
		File f=new File("g:/java");
		String[]str=f.list(new FilenameFilter(){
			public boolean accept(File f,String name){
				
				return name.endsWith(".txt");//返回文件及文件夹名称以“.txt”为结尾的文件及文件夹
//				System.out.println(f+"---------name:"+name);//f表明文件目录，name表明文件夹名称及文件名称
//				return false;//返回false表示不返回
//				return true;//返回true表示返回
			}
		});
		for(String string:str){
			System.out.println(string);
		}
	}
	/*
	 * //列出根文件下全部文件，文件夹，及隐藏文件
	 */
	public static void list(){
		File f=new File("g:/java");//调用list()方法，该File对象必须封装一个目录，不能是文件,而且该目录确实存在才行
		String[] str=f.list();
		for (String string : str) {
			System.out.println(string);
		}
	}
	/*
	 * File.listRoots():获取可用的文件系统根，简单来讲就是获取系统的盘符
	 */
	public static void listRoots(){
		File[] f=File.listRoots();
		for (File file : f) {
			System.out.println(file);
		}
		System.out.println(f[0]);
		
	}
}