Java File文件类,文件过滤器,递归的使用

public class DemoTwo {

	public static void main(String[] args) throws IOException {
		//可以根据顺序进行反注释执行
		//createFile();
		//creatDirectory();
		//delectFile();
		//getFileName();
		//getFileByte();
		//fileJudge();
		//getFileList();
		//getListFiles();
		//getListRoots();
		//getFileFilter();
		
		//遍历全目录文件,文件夹,使用递归
		//File file = new File("C:\\test");
		//getAllDir(file);
		
		//递归练习1+2+...n结果
		//System.out.println(getSum(100));
		
		//递归练习n的阶乘
		//int sum = getFactorial(5);
		//System.out.println(sum);
		
		//递归 兔子问题
		//System.out.println(getSeries(12));
		
		//递归遍历多级目录,过滤掉所有不是.java的文件
		//File file = new File("C:\\test");
		//getAllJava(file);
		
		
	}
	/**  递归遍历多级目录,过滤掉所有不是.java的文件
	 * 	目录结构:
	 * 	 	C:\test
	 * 		C:\test\a
	 * 		C:\test\a\2.java
	 * 		C:\test\a\1.txt
	 * 		C:\test\a.txt
	 * 		C:\test\b
	 * 		C:\test\b\3.java
	 * 		C:\test\b\DemoOne.JAVA    java区分大小写
	 * 		C:\test\b\2.txt
	 * 		C:\test\Demo.java
	 */
	private static void getAllJava(File file) {
		File[] listFiles = file.listFiles(new MyFileFilterB());
		for (File f : listFiles) {
			if(f.isDirectory()){//判断是否是文件夹
				getAllJava(f);
			}else{
				System.out.println(f);
			}
		}
	}
	/*
	 * 兔子问题,和斐波那契
	 * 	一对兔子,第一个第二个月不生,第三个月开始生1对兔子,生下的兔子第一第二个月不生第三个月开始,每个月生1对兔子
	 * 12个月以后一共有多少对兔子
	 * 
	 * 设n=5;调用流程:
	 * 
	 *  ↓ getSeries(5 - 1) 			  +     	getSeries(5 - 2)........
	 *  		↓ getSeries(4 - 1) 	  +	         ↖ ○→getSeries(4 - 2)→ 
	 *  				↓ getSerice(3 - 1)		 true		  ↓
	 *  				↓	true			↑ ←	  return 1; 		 		
	 *  				 →	return 1;		↑
	 */
	private static int getSeries(int n) {
		if(n == 1 || n == 2)
			return 1;
		return getSeries(n - 1) + getSeries(n - 2);
	}

	/**
	 * 计算5阶乘
	 * 5*4*3*2*1
	 * 注:过多的进出栈会导致内存溢出,Java方法进出栈次数是根据电脑配置来决定的
	 */
	private static int getFactorial(int n) {
		if(n == 1)
			return 1;
		return n * getFactorial(n - 1);
	}
	/**
	 * 获取1+2+...n结果,使用递归,这种题使用递归较慢,不建议实际开发中使用
	 * 每次都是sum=sum+sum+1;
	 * 如果是n=100
	 * 规律:
	 * 		n=(n-1)+n=(n-1)...
	 * 
	 * 代码执行顺序,设n=3;
	 * 		getSum(3),3==1 false,return 3 + getSum(3 - 1)
	 * 						调用getSum(2),2 == 1 false, return 2 + getSum(2 - 1)
	 * 								调用getSum(1),1 == 1 true return 1;
	 * 								返回1后,第二次调用getSum执行:2+1=3 return 第一次调用getSum执行 return 3 + 3 = 6 ,运行结果就是6
	 * 								后面补充图
	 * 
	 */
	private static int getSum(int n) {
		if(n == 1)
			return 1;
		return n + getSum(n - 1);
	}
	/**
	 * 如何遍历一个目录下所有文件呢?
	 * 目录结构:
	 * 一级目录:
	 *  	C:\test
	 *  	C:\test\a
	 *  	C:\test\b
	 *  	C:\test\a.txt
	 *  	C:\test\Demo.java
	 *  二级目录:
	 *  	C:\test\a\1.txt
	 * 	    C:\test\b\2.txt
	 * listFiles()只能遍历一层目录,这个方法每次都需要传递参数,那么我每次遇到文件夹
	 * 就对文件夹进行传递参数遍历这样每层目录都会被遍历
	 * 第一次:getArrDir(File file)file=C:\\test
	 * 		对该目录进行遍历,判断如果是文件夹则进行再次遍历
	 * 			a.isDirectory()==true;调用getAllDir(File file) file=C:\\test\\a
	 * 				这时会对该目录进行遍历,如果遍历完成则方法结束进行第一次循环的第二个目录进行判断以此类推
	 * 运行结果:
	 * 		C:\test\a\1.txt
	 * 		C:\test\a.txt
	 * 		C:\test\b\2.txt
	 * 		C:\test\Demo.java
	 * 会发现a,b目录没了输出,我们getAllDir(File file) file就是目录路径,每次方法调用都会传递不同目录进行遍历,对该目录进行输出即可
	 * 
	 * 最终运行结果:
	 * 		C:\test
	 * 		C:\test\a
	 * 		C:\test\a\1.txt
	 * 		C:\test\a.txt
	 * 		C:\test\b
	 * 		C:\test\b\2.txt
	 * 		C:\test\Demo.java
	 * 
	 * 这种调用方式叫做:递归
	 * 		方法递归调用:自己调用自己
	 * 		需要有终止条件,停止递归调用的条件
	 * 		递归调用次数不能过多,JVM内存有限,设2亿调用,内存肯定会溢出
	 * 		构造方法不可递归
	 * 		适用于方法主体不变,运行时参数会变化
	 * 		
	 * 
	 * 递归有两种调用方法
	 * 		1.直接调用(常用),自己调用自己
	 * 		2.间接调用(不常用),A调用B,B调用C,C调用A,这种方式不建议使用,产生死循环的几率比较大
	 */
	private static void getAllDir(File file) {
		System.out.println(file);
		File[] listFiles = file.listFiles();
		for (File f : listFiles) {
			//首先判断该目录下是否存在目录,如果存在则调用方法遍历该目录
			if(f.isDirectory()){
				getAllDir(f);//将当前遍历的文件夹进行遍历
			}else{
				System.out.println(f);
			}
		}
	}
	/**
	 * 文件过滤器:根据需要过滤掉不需要的文件
	 * ListFiles(FileFilter filter)重载形式
	 * FileFilter接口没有实现类,需要我们自己实现,重写抽象方法
	 * c盘下test文件夹两个文件a.txt,Demo.java,目的:过滤掉.txt文件
	 * 
	 * listFiles(FileFilter filter)会先获取文件,文件夹,然后将文件传给FileFilter的抽象方法accept(File pathname)
	 * 	方法对文件进行过滤判断返回是否符合要求,如果返回为true则存储到File数组中
	 */
	private static void getFileFilter() {
		File file = new File("C:\\test");
		File[] fileArray = file.listFiles(new MyFileFilter());//传入过滤器实现类
		for (File file2 : fileArray) {
			System.out.println(file2);
		}
	}
	/**
	 * 获取系统中所有根目录
	 */
	private static void getListRoots() {
		File[] listRoots = File.listRoots();
		for (File file : listRoots) {
			System.out.println(file);
		}
	}

	/**
	 * 获取封装路径下的文件和文件夹
	 * 返回File[]
	 * 返回数组有文件,文件夹的全路径
	 * 推荐使用,如需返回字符串可使用toString()
	 */
	private static void getListFiles() {
		File file = new File("c:");
		File[] fileArray = file.listFiles();
		for (File file2 : fileArray) {
			System.out.println(file2);
		}
	}


	/**
	 * 获取封装的路径下文件和文件夹
	 * 返回String[]
	 * 返回数组只有文件,文件夹名称
	 * 遍历路径下的所有文件和文件夹,包含系统隐藏文件,遍历目录
	 */
	private static void getFileList() {
		File file = new File("c:");
		String[] list = file.list();
		for(String s : list){
			System.out.println(s);
		}
	}



	/**
	 * 判断文件,文件夹是否存在
	 * 是否是文件夹和文件 
	 * 返回boolean值
	 */
	private static void fileJudge() {
		File file = new File("D:\\abc\\a\\b");//D:\\a.txt
		//文件,文件夹是否存在,一般要对文件进行操作时都需要先判断文件,文件夹是否存在(安全)
		boolean exists = file.exists();
		System.out.println("exists: " + exists);
		//是否是文件夹
		boolean directory = file.isDirectory();
		System.out.println("isDirectory: " + directory);
		//是否是文件
		boolean file2 = file.isFile();
		System.out.println("isFile: " + file2);
		//是否时绝对路径
		boolean absolute = file.isAbsolute();
		System.out.println("absolute: "+ absolute);
		
	}
	/**
	 * 获取文件的字节数,文件绝对,相对路径,父路径
	 */
	private static void getFileByte() {
		File file = new File("D:\\a.txt");
		long length = file.length();
		System.out.println(length);
		
		//获取绝对路径这两个方法返回值不同,根据需要选择,在eclipse中如果路径为相对路径,那么默认获取的路径就是工程的根目录
		String absolutePath = file.getAbsolutePath();
		System.out.println(absolutePath);
		
		File absoluteFile = file.getAbsoluteFile();//建议使用
		System.out.println(absoluteFile);
		
		//获取父路径,和上面连个方法一样返回值一个String,一个File(建议使用)
		File parentFile = file.getParentFile();
		System.out.println(parentFile);
	}



	/**
	 * 获取文件,文件夹名称
	 * 获取构造器内传入的文件,文件夹名称
	 */
	private static void getFileName() {
		File file = new File("D:\\abc\\a.txt");
		String name = file.getName();
		System.out.println(name);
		System.out.println(file.getPath());//和File对象的toString()方法一样
	}




	/**
	 * 删除文件,文件夹
	 * 返回boolean值
	 * 如果不存在则返回false,反之则删除
	 * 写文件路径就删除文件,文件夹就删除文件夹
	 * 删除不走回收站,直接从硬盘中删除
	 */
	private static void delectFile() {
		//删除文件夹
		/*File file = new File("D:\\abc\\a\\b\\c");
			boolean delete = file.delete();
			System.out.println(delete);
		*/
		//删除文件
		File file1 = new File("D:\\abc\\a\\b\\a.txt");
		boolean delete1 = file1.delete();
		System.out.println(delete1);
	}
	/**
	 * 创建文件夹
	 * 返回boolean值
	 * 如果存在则返回false,反之则创建
	 * 如果文件夹路径有后缀名创建的也是文件夹
	 * mkdir();用于创建一级文件夹,如果多级会创建失败可以使用mkdirs();来进行多级文件夹创建
	 */
	private static void creatDirectory() {
		File file = new File("D:\\abc\\a\\b\\c");
		boolean mkdirs = file.mkdirs();
		System.out.println(mkdirs);
	}
	/**
	 * 创建文件
	 * 返回boolean值
	 * 如果存在则返回false,反之则创建
	 * 如果文件路径没有后缀名创建的也是文件
	 */
	private static void createFile() throws IOException {
		File file = new File("D:\\a.txt");
		boolean createNewFile = file.createNewFile();
		System.out.println(createNewFile);
	}

}
/**
 *  一级目录过滤器
 */
class MyFileFilter implements FileFilter{

	@Override
	public boolean accept(File pathname) {
		//判断字符串后缀是否是.java结尾
		return pathname.getName().endsWith(".java");
	}
	
}
/**
 * 多级目录过滤器
 */
class MyFileFilterB implements FileFilter{

	@Override
	public boolean accept(File pathname) {
		//判断字符串后缀是否是.java结尾
		return pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java");//将文件名转换大小写在判断
	}
	
}