IO流五：File类及常用方法、递归、递归的练习

1  File类及其常见方法

File类把文件或文件夹封装成对象，方便对文件及文件夹的属性信息进行操作。

File对象可以作为参数，传递给IO流对象的构造函数。以替代文件的URL地址的字符串形式。

 

File类常见方法。

1，创建。

boolean createNewFile()：在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立就创建文件，而且若文件已经存在，则覆盖。

boolean mkdir()：创建此抽象路径名指定的目录。当已创建目录时，返回 true。但是mkdir()只能创建一级目录。

boolean mkdirs()：创建指定的路径的文件夹，可以创建多级目录。

 

2，删除。

boolean delete()： 删除此抽象路径名表示的文件或目录，删除失败返回false

void deleteOnExit()： 在虚拟机终止时，删除此抽象路径名表示的文件或目录。

 

3，判断。

boolean canExecute()：判断应用程序是否可以执行此抽象路径名表示的文件，可以执行则返回true。如果此文件不存在，则返回false。

boolean exists()：判断此抽象路径名表示的文件或目录是否存在，比较常用的。

boolean isDirectory()：判断此抽象路径名表示的文件是否是一个目录(文件夹)。前提是此文件已经存在。

boolean isFile()：判断此抽象路径名表示的文件是否是一个标准文件。前提是此文件已经存在

boolean isHidden()：判断此抽象路径名指定的文件是否是一个隐藏文件。前提是此文件已经存在

boolean isAbsolute()：判断此抽象路径名是否为绝对路径名。带着盘符为绝对路径。此路径不存在也可以判断。

4，获取信息。

getName()：返回由此抽象路径名表示的文件或目录的名称。

getPath()：将此抽象路径名转换为一个路径名字符串。

getParent()：返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回null。

File getAbsoluteFile()：返回此抽象路径名的绝对路径名形式，并封装成File对象。

String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。

long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。

long length()：返回由此抽象路径名表示的文件的长度。

5，  boolean renameTo(File dest)：重新命名此抽象路径名表示的文件，可以移动到其他路径下。

 

常用方法演示和注释：

import java.io.*;

class FileDemo {
	public static void main(String[] args) throws IOException{
		method_6();
	}
	
	//创建File对象。
	public static void consMethod() {
		//将 a.txt 封装成File对象。可以将已有的或未出现的文件或文件夹，封装成对象。
		File f1 = new File("e:\\FileDemo\\a.txt");
		
		//把e:\FileDemo目录下的 b.txt封装成File对象。
		File f2 = new File("e:\\FileDemo","b.txt");
		
		//把d变量指向的目录下的 c.txt封装成File对象。
		File d = new File("e:\\FileDemo");
		File f3 = new File(d,"c.txt");
		
		//File的separator字段返回跨平台的目录分隔符。
		File f4 = new File("e:"+File.separator+"EVE.jpg");
		
		sop("f1: "+f1);
		sop("f2: "+f2);
		sop("f3: "+f3);
		sop("f4: "+f4);
	}
	
	public static void sop(Object obj){
		System.out.println(obj);
	}
	
	//创建和删除
	public static void method_1() throws IOException{
		File f = new File("e:\\file.txt");
		
		f.deleteOnExit(); //在程序终止时删除这个文件。
		//文件在被使用时，无法删除，只能等程序结束后再删除。
		
		sop("create: "+f.createNewFile());
		//sop("delete: "+f.delete());
	}
	
	//判断
	public static void method_2(){
		File f = new File("e:\\file.txt");
		
		sop("此文件存在吗："+f.exists());
		sop("是否可执行："+f.canExecute());
	}
	
	//创建：mkdir() mkdirs() 
	public static void method_3(){
		//使用mkdir()方法，创建dir1路径，在E盘下创建mkdir文件夹。只能创建一级目录。
		File dir1 = new File("e:\\mkdir一级目录");
		dir1.mkdir();
		
		//使用mkdir()方法，创建dir2路径，可以创建多级目录。
		File dir2 = new File("e:\\mkdir多级目录\\aaa\\bbb\\ccc");
		dir2.mkdirs();
	}
	
	//判断
	public static void method_4(){
		File f = new File("e:\\file.txt");
		
		//记住，在判断文件对象是否是文件或目录时，必须先判断该文件对象封装的内容是否存在。
		//通过exists()方法判断。
		sop("存在吗："+f.exists());
		
		sop("dir: "+f.isDirectory());  //判断是不是目录
		sop("file: "+f.isFile()); //判断是不是一个文件
		
		//判断是不是绝对路径。带盘符的是绝对路径。不存在也可以判断。
		sop("是不是一个绝对路径："+f.isAbsolute());
	}
	
	//获取
	public static void method_5(){
		File f = new File("fos.txt");
		
		sop("父目录："+f.getParent());  
		//返回绝对路径中的文件父目录。若是相对路径，返回null。
		//如果相对路径中，有上一级目录，则返回父目录，比如"dir\abc"返回dir
		
		sop("路径："+f.getPath());  //返回路径
		sop("绝对路径："+f.getAbsolutePath());  //返回绝对路径
		sop("最后一次被修改时间："+f.lastModified()+"毫秒前"); //返回上一次被修改的时间
		sop("大小："+f.length()+"字节");  //返回大小
	}
	
	//5, renameTo  重命名，可以移动到其他路径下。
	public static void method_6(){
		File f1 = new File("e:\\GetUp-副本.mp3");
		File f2 = new File("d:\\GetUp-renameTo.mp3");
		
		sop("重命名："+f1.renameTo(f2));
	}
}

2  File对象功能：文件列表

文件列表相关的方法：

File[] listRoots()：静态方法，列出可用的文件系统根。

 

String[] list()：以字符串数组形式，返回指定目录下的所有文件或文件夹的名称，包括隐藏文件。如果此抽象路径名不表示一个目录，或者发生 I/O 错误，则返回 null。即必须是一个目录，并且已经存在。

 

String[] list(FilenameFilter filter)： 根据过滤器filter，返回指定目录下满足过滤器的文件或目录。需要实现接口FilenameFilter的 accept方法。

FilenameFilter接口中的accept方法：

boolean accept(File dir,String name)：dir——被找到的文件所在的目录。name——需要过滤的文件的名称。

其实 FilenameFilter接口就是过滤器，accept方法就是过滤方法。

 

File[] listFiles()：以File对象数组的形式，返回指定目录下所有文件或文件夹。

 

代码示例：

import java.io.*;

class FileDemo2 {
	public static void main(String[] args){
		listFilesDemo();
	}
	
	public static void listRootsDemo(){
		File[] files = File.listRoots(); //列出本地中所有盘符。
		
		for(File f : files){ //增强for循环遍历files数组。
			System.out.println(f);
		}
	}
	
	public static void listDemo(){
		File f = new File("E:\\");
		
		String[] names = f.list();//以字符串数组形式，返回指定目录下的所有文件或文件夹的名称。
		
		for(String name : names){
			System.out.println(name);
		}
	}
	
	//list(FilenameFilter filter)  文件名过滤演示。
	public static void listDemo_2(){
		File dir = new File("e:\\java");
		                                        //接口FilenameFilter：过滤器
		String[] arr = dir.list(new FilenameFilter(){   //接口FilenameFilter的匿名内部类
			public boolean accept(File dir,String name){  //返回true，则此文件符条件。添加到arr数组中。
				return name.endsWith(".txt");  //用过滤器找到所有txt文件
			}
		});
		System.out.println("len: "+arr.length);
		
		for(String name : arr){
			System.out.println(name);
		}
	}
	
	//listFiles()  返回指定目录下的，文件或文件夹的File对象数组。
	public static void listFilesDemo(){
		File dir = new File("e:\\java");
		File[] files = dir.listFiles();
		
		for(File f: files){
			System.out.println(f.getName()+"......"+f.length()+"字节");
		}
	}
}

3  列出目录下所有内容（递归）

列出指定目录下所有的文件和文件夹，包括文件夹中的文件，即包含子目录中的内容。

也就是列出指定目录下所有内容。

 

因为目录中包含目录，只要使用同一个列出所有文件和目录的函数即可。

在列出过程中，出现的还是目录的话，可以再次调用本功能。

也就是函数自身调用自身。

这种自身调用自身，就称为递归。

 

递归要注意：

1，限定条件。

2，要注意递归的次数，尽量避免内存溢出。

 

代码示例：

import java.io.*;

class FileDemo3 {
	public static void main(String[] args){
		File dir = new File("E:\\java");
		showDir(dir,0);
		//toBin(6);
	}
	
	//列出目录下所有内容——递归
	public static void showDir(File dir,int level){
		System.out.println(getLevel(level)+dir.getName());
		File[] files = dir.listFiles(); //列出所有文件及目录，返回File[]数组
		
		level++;
		for(int x=0; x<files.length; x++){
			if(files[x].isDirectory()) //判断是否是一个目录
				showDir(files[x],level); //是目录就递归调用
			else
				System.out.println(getLevel(level)+files[x].getName());
		}
	}
	
	//列出目录下所有内容——带层次
	public static String getLevel(int level){
		StringBuilder sb = new StringBuilder();
		sb.append("|--");
		for(int x=0; x<level; x++){
			sb.insert(0,"|  ");
		}
		return sb.toString();
	}
	
	public static void toBin(int num){ //十进制转换成二进制。
		if(num>0){
			toBin(num/2);
			System.out.println(num%2);
		}
	}
	
	public static int getSum(int n){ //小于等于n且大于0的所有整数的和。
		if(n==1)
			return 1;
		return n+getSum(n-1);
	}
}

4  删除一个带内容的目录

删除原理：

在Windows中，删除目录是从里面往外删除，即首先删除最里面子目录下的文件。

既然是从里往外删除，就需要用到递归。

 

代码示例

import java.io.*;

class RemoveDir{
	public static void main(String[] args){
		File dir = new File("E:\\kankan");
		removeDir(dir);
	}
	 
	public static void removeDir(File dir){ //删除dir目录下所有内容
		File[] files = dir.listFiles(); //列出所有文件及目录，返回File[]
		
		for(int x=0; x<files.length; x++){
			if(files[x].isDirectory()) //若是目录，继续递归调用
				removeDir(files[x]);
			else
				System.out.println(files[x].toString()+"::file::"+files[x].delete());
		}
		
		//继续删除空目录
		System.out.println(dir+"::dir::"+dir.delete());
	}
}

5  练习：创建Java文件索引

练习：

将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。

建立一个java文件索引文件。

思路：

1，对指定的目录进行递归。

2，获取递归过程中所有的java文件的路径。

3，将这些路径存储到集合中。

4，将集合中的数据写入到一个文件中。

 

代码示例：

import java.util.*;  //集合
import java.io.*;    //File类

class JavaFileList {
	public static void main(String[] args) throws IOException{
		File dir = new File("e:\\java"); //遍历此目录下所有java文件
		List<File> list = new ArrayList<File>(); //存储路径文件的集合
		
		fileToList(dir,list);
		System.out.println(list.size());
		
		File file = new File(dir,"javalist.txt"); //此列表文件保存到dir目录下的javalist.txt文件
		writeToFile(list,file.toString());
	}
	
	//递归方法。将dir目录下的所有java文件的路径，存储到list集合中。
	public static void fileToList(File dir,List<File> list){
		File[] files = dir.listFiles(); //列出所有文件及目录
		
		for(File file : files){
			if(file.isDirectory()) //若是目录，继续递归遍历
				fileToList(file,list);
			else{
				if(file.getName().endsWith(".java"))
					list.add(file); //若是java文件，添加到集合中
			}
		}
	}
	
	//把集合list中每个File对象代表的路径，存储到javaListFile代表的文件中。
	public static void writeToFile(List<File> list,String javaListFile) throws IOException{
		BufferedWriter bufw = new BufferedWriter(new FileWriter(javaListFile));
			
		for(File f : list){
			String path = f.getAbsolutePath(); //获取绝对路径
			bufw.write(path); //把路径写入流中
			bufw.newLine();
			bufw.flush();	
		}
		bufw.close();
	}
}