Java_File

递归:

	直接递归和间接递归
递归一定要有条件限定，能够保证停下来，否则会发生栈内存溢出
递归的次数不能太多，否则也会发生栈内存溢出
构造方法禁止递归，编译报错，构造方法是创建对象时使用，一直递归，导致内存中对象太多，所以直接报错
当调用方法的时候，方法的主体不变，每次调用方法的参数不同，可以使用递归	
=============

public class DiGui {

	public static void main(String[] args) {
//		a();
		b(1);
	}
	private static void a(){
		System.out.println("a方法");
		a();//会发生栈内存溢出。
	}
	private static void b(int i){
		System.out.println(i);
		if(i==20000){
			return;//结束方法,次数太多也会报错，次数少一点不会
		}
		b(++i);
	}
}

---

import java.util.Scanner;

/*
 * 	使用递归计算阶乘
 * 
 */
public class DiGuiTes02 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个整数");
		int n = sc.nextInt();
		int s = jc(n);
		System.out.println(s);
	}
	public static int jc(int n){
		if(n==1){
			return 1;
		}
		//下一个数字，通过递归来获取下一个数字。
		return n * jc(n-1);
		
	}
}

-------------------------
import java.util.Scanner;

/*
 *	 练习:
 * 		使用递归计算1-n之间的和
 * 	方法先入栈，等到==1时。1返回给调用它的方法，依次返回，反向递加结果。
 * 		main方法调用sum方法，内存中有多个sum方法频繁的调用方法，销毁方法，效率低下。
 * 
 */
public class DiGuiTest01 {

	public static void main(String[] args) {
		Scanner sc =new Scanner(System.in);
		System.out.println("请输入一个整数");
		int n = sc.nextInt();
		int s = sum(n);
		System.out.println(s);
	}
	public static int sum(int n){
		if(n==1){
			return 1;
		}
		//获取下一个被加的数字
		return n + sum(n-1);
		
	}
}

------------------------------
import java.io.File;

/*
 * 	使用递归打印多级目录:
 * 		遍历一个文件夹
 * 	遍历的结果并不完整，没有子文件夹里面的东西
 * 		对f进行判断，是否是文件夹，如果是文件夹，继续遍历
 * 		如果是文件直接打印。
 */
public class DiGuiTest03 {

	public static void main(String[] args) {
		File file = new File("C:\\MyDrivers");
		getAll(file);
	}
	//参数file类型的目录
	public static void getAll(File dir){
		//打印被遍历的名称
		System.out.println(dir);
		File[] files = dir.listFiles();
		for (File f : files) {
			if(f.isDirectory()){
				//递归调用
				getAll(f);
			}else{
			System.out.println(f);
			}
		}
	}
}

-----------------------------
import java.io.File;

/*
 * 	遍历目录只要以什么结尾的文件.
 * 
 */
public class DiGuiTest04 {

	public static void main(String[] args) {
		File file = new File("D:\\1907testjava\\day01");
		getAll(file);
	}
	//参数file类型的目录
	public static void getAll(File dir){
		//打印被便利的名稱
//		System.out.println(dir);
		File[] files = dir.listFiles();
		for (File f : files) {
			if(f.isDirectory()){
				//递归调用
				getAll(f);
			}else{
				/*
				 * String类中endwith
				 * 把file对象f转换为字符串对象
				 * 		f.get
				 * 
				 */
//			String name = f.getName();//获取文件名称
//			String path = f.getPath();
			String s = f.toString();
			//把字符串转换为小写
			s = s.toLowerCase();
			boolean b = s.endsWith(".java");
//			如果是.java结尾则输出
			if(b){
				System.out.println(f);
			}
			
			//链式编程
			if(f.getName().toLowerCase().endsWith(".java")){
				System.out.println(f);
			}
			
			}
		}
	}
}

---

File

java.io.File类
文件和目录路径名的抽象表达式
java把电脑中的文件和文件夹（目录）封装成为了一个File类，我们可以使用File类
对文件和文件夹进行操作。
创建，删除，获取，判断是否存在，遍历，获取文件的大小
File类是一个与系统无关的类，任何的操作系统都可以使用这个类中的方法
file文件 directory 文件夹 目录 path路径
===============

public class FileCls {

	public static void main(String[] args) {
		/*
		 * File类的静态成员变量
		 * static String pathSeparator:与系统有关的路径分隔符，他被表示为一个字符串
		 * static char pathSeparatorChar:与系统有关的路径分隔符
		 * 
		 * static String separator:与系统有关的默认名称分隔符，他被表示为一个字符串
		 * static char separatorChar:与系统有关的默认名称分隔符
		 * 
		 * 工作中操作路径不能写死，需要这样写
		 * 		C:\develop\a\a.txt
		 * 	    "C:"+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt"
		 * 
		 */
		String pathSeparator = File.pathSeparator;
		System.out.println(pathSeparator);//;
		String path01 = File.separator;
		System.out.println(path01);// \
		char path02 = File.pathSeparatorChar;
		System.out.println(path02);//;
		char path03 = File.separatorChar;
		System.out.println(path03);// \
	}
}

----------------------
import java.io.File;

/*
 * File类的判断功能的方法:
 * 		public boolean exists():判断文件或者目录是否存在
 * 		public boolean isDirectory():
 * 				由此File表示的目录是否存在
 * 		public boolean isFile():表示是否为文件
 * 
 */
public class FileBoolean {
	public static void main(String[] args) {
//		show01();
		show02();
	}
	/*
	 * public boolean exists():判断文件或者目录是否存在
	 * 		用于判断构造方法中的路径是否存在
	 * 		存在:true 	不存在L:false
	 */
	public static void show01(){
		File f1 = new File("D:\\Hello java\\javaPro");
		boolean y = f1.exists();
		System.out.println(y);//存在为true
		File f2 = new File("D:\\Hello java\\javaPro\\dd");
		System.out.println(f2.exists());//不存在为false
		File f3 = new File("javaPro");
		System.out.println(f3.exists());//不存在为false
	}
	/*
	 * public boolean isDirectory():由此File表示的目录是否存在
	 * 		判断给定的路径是否以文件夹结尾，是true 否false
	 * public boolean isFile():表示是否为文件
	 * 		判断给定的路径是否以文件结尾，是true 否false
	 * 		电脑中的文件要么是文件，要么是文件夹
	 * 		这两个方法的使用前提，路径必须是存在的，否则都返回false
	 * 			所以使用之前进行判断
	 */
	public static void show02(){
		File f1 = new File("D:\\Hello java\\javaPro");
		if(f1.exists()){
			System.out.println(f1.isDirectory());
			System.out.println(f1.isFile());
		}
		//不存在就不获取了
		File f2 = new File("D:\\Hello java\\javaPro\\dd");
		if(f2.exists()){
			System.out.println(f2.isDirectory());
			System.out.println(f2.isFile());
		}
	}
}

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

/*
 * 	File类创建和删除功能的方法
 * 		public boolean createNewFile():当且仅当具有该名称的文件时，创建一个新的文件夹
 * 		public boolean delete():删除此file表示的文件或目录
 * 		public boolean mkdir():创建此file表示的目录
 * 		public boolean mkdirs():创建此file表示的目录，包括任何必须但不存在的目录
 * 
 * 
 */
public class FileCreateDel {

	public static void main(String[] args) throws IOException {
//		show01();
//		show02();
		show03();
	}
	/*
	 * public boolean createNewFile():当且仅当具有该名称的文件不存在时，创建一个新的文件
	 * 		创建文件的路径和名称在构造方法中给出(构造方法的参数)
	 * 		返回值:布尔值
	 * 			true:文件不存在，创建返回值true
	 * 			false:文件存在，返回false
	 * 		此方法只能创建文件，不能创建文件夹
	 * 		创建文件的路径必须存在，否则会抛出异常
	 * 
	 */
	private static void show01() throws IOException{
		File f1 = new File("E:\\p2\\bb.txt");
		boolean b1 = f1.createNewFile();
		System.out.println(b1);
		File f2 = new File("All Users\\b.txt");
		boolean b2 = f1.createNewFile();
		System.out.println(b2);
	}
	/*
	 * public boolean mkdir():创建单级文件夹
	 * public boolean mkdir():既可以创建单级也可以创建多级
	 * 		文件夹不存在创建返回true
	 * 		文件夹存在:返回false
	 * 		此方法只能创建文件夹，不能创建文件。
	 */
	private static void show02(){
		File f1 = new File("E:\\p2\\bb");
		boolean b1 = f1.mkdir();
		System.out.println(b1);
		//只能创建单级文件夹
		File f2 = new File("E:\\p2\\cc\\dd\\ee");
		boolean b2 = f2.mkdir();
		System.out.println(b2);
		
		File f3 = new File("E:\\p2\\cc\\dd\\ee");
		boolean b3 = f3.mkdirs();
		System.out.println(b3);
	}
	/*
	 * public boolean delete():删除此file表示的文件或目录
	 * 		此方法，可以删除构造方法中给出的文件/文件夹
	 * 		返回值:布尔值
	 * 		true:文件/文件夹删除成功，返回true
	 * 		false:文件夹中有东西，不会删除返回false,构造方法中的路径不存在yefanhuifalse
	 * 		这个方法删除步骤回收站，直接删除硬盘文件
	 * 
	 */
	private static void show03(){
		File f1 = new File("E:\\p2\\bb");
		boolean b1 = f1.delete();
		System.out.println(b1);
		File f2 = new File("E:\\p2\\bb.txt");
		boolean b2 = f2.delete();
		System.out.println(b2);
	}
	
}

------------------------------
import java.io.File;

/*
 * File类遍历:
 * 		public String[] List() :返回一个String数组，表示File目录中所有的子文件或目录
 * 		public File[] ListFiles():返回一个File数组，表示File目录中的所有子文件或目录
 * 			遍历构造方法中给出的参数
 * 			如果给出的路径不存在抛出空指针异常
 * 			给出的路径不是目录，也会抛出空指针异常
 * 
 */
public class FileForeach {

	public static void main(String[] args) {
//		show01();
		show02();
	}
	/*
	 * public String[] List() :返回一个String数组，表示File目录中所有的子文件或目录
	 * 		获取目录中所有文件/文件夹的名称，获取到多个名称存储到String类型的数组之中
	 * 		打印子目录
	 */
	private static void show01(){
		File f1 = new File("C:\\MyDrivers");
		String[] list = f1.list();
		for (String string : list) {
			System.out.println(string);
		}
		
	}
	/*
	 * public File[] ListFiles():返回一个File数组，表示File目录中的所有子文件或目录
	 * 		构造方法中给出的目录，会获取目录中的所有的文件/文件夹，把文件/文件夹封装为File对象
	 * 		多个File对象存储到File数组中
	 * 		打印绝对路径
	 */
	private static void show02(){
		File f1 = new File("C:\\MyDrivers");
		File[] files = f1.listFiles();
		for (File file : files) {
			System.out.println(file);
		}
	}
}

----------------------------
import java.io.File;

/*
 * 	绝对路径和相对路径:
 * 		绝对路径:完整的路径，以盘符开始的 C,D
 * 		相对路径:一个简化的路径，相对指的是相对于当前项目的根目录,可以省略项目的根路径
 * 		
 * 	路径是不区分大小写的
 * 	路径中的文件名称分隔符windows中使用反斜杠,反斜杠为转义字符,两个反斜杠代表一个普通的反斜杠	
 * 	
 * 	File类的构造方法:
 * 		构造方法可以创建对象
 * 		
 * 	
 * 
 */
public class FileLuJing {

	public static void main(String[] args) {
		/*
		 * File类的构造方法
		 */
//		show01();
//		show02("c:\\","a.txt");
		show03();
	}
	/*
	 * File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建一个File实例
	 * 	参数:
	 * 		String pathname :	字符串的路径名称
	 * 		路径可以是以文件结尾，也可以是文件夹
	 * 		可以是相对路径，也可以是绝对
	 * 		路径可以存在，也可以不存在
	 * 		创建File对象，只是把字符串路径封装为File对象，不考虑路径的真假情况
	 */
	public static void show01(){
		File f1 = new File("D:\\Hello java");
		System.out.println(f1);
	}
	/*
	 * File(String parent,String child)
	 * 		根据parent 路径名字符串和child路径名字符串创建一个新的File实例 
	 * 把路径分成两部分:
	 * 		String parent 
	 * 		String child
	 * 	父路径和子路径，可以单独书写，使用起来非常灵活，父路径和子路径可以变化
	 */
	public static void show02(String parent,String child){
		File file = new File(parent,child);
		System.out.println(file);
	}
	/*
	 * File(File parent,String child) 根据parent抽象路径名和child路径名字创建一个
	 * 新的File
	 * 		参数:
	 * 			File parent:File类型的父路径，可以使用File类的方法对路径进行一些操作
	 * 			String child
	 * 
	 */
	public static void show03(){
		File parent = new File("c:\\");
		File file = new File(parent,"hello.java");
		System.out.println(file);
		
	}
}

------------------------------
import java.io.File;

/*
 * File类获取功能的方法
 * 		public String getAbsolutePath():返回此file的绝对路径名字字符串
 * 		public String getPath():将此file转换为路径名字字符串
 * 		public String getName():返回此file表示的文件或目录的名称
 * 		public Long Length():返回此File表示的文件的长度
 * 
 * 
 */
public class FileMethod {
	public static void main(String[] args) {
//		show01();
//		show02();
//		show03();
		show04();
	}
	/*
	 * 	public String getAbsolutePath():返回此file的绝对路径名字字符串
	 * 	获取的构造方法中传递的路径
	 * 	无论是绝对的还是相对的，getAbsolutePath方法返回的都是绝对路径
	 */
	private static void show01(){
		File f1 = new File("C:\\MyDrivers\\backup");
		String absolutePath = f1.getAbsolutePath();
		System.out.println(absolutePath);
		File f2 = new File("backup");
		String absolutePath2  = f2.getAbsolutePath();
		System.out.println(absolutePath2);//D:\jxb.eeeee\day_08_file\backup
	}
	/*
	 * public String getPath():将此file转换为路径名字字符串
	 * 		获取构造方法中传递的路径，无论是绝对的还是相对的
	 * 		toString方法调用的就是getPath方法
	 * 
	 */
	public static void show02(){
		File f1 = new File("C:\\MyDrivers\\backup");
		String path = f1.getPath();
		System.out.println(path);
		File f2 = new File("backup");
		String path2 = f2.getPath();
		System.out.println(path2);
	}
	/*
	 * public String getName():返回此file表示的文件或目录的名称
	 * 		获取的就是构造方法传递路径的结尾部分（文件/文件夹）
	 * 
	 */
	public static void show03(){
		File f1 = new File("C:\\MyDrivers\\backup\\a.txt");
		String name1 = f1.getName();
		System.out.println(name1);//a.txt
		File f2 =new File("C:\\MyDrivers\\backup");
		String name2 = f2.getName();
		System.out.println(name2);//backup
	}
	/*
	 * 	public Long Length():返回此File表示的文件的长度
	 * 		获取构造方法指向文件的大小，以字节为单位，
	 * 		文件夹是没有大小概念的，不能获取文件夹，如果构造方法给出的路径不存在
	 * 		那么length方法返回0
	 * 		
	 */
	public static void show04(){
		File f1 = new File("D:\\a.jpeg");
		long l = f1.length();
		System.out.println(l);
		File f2 = new File("D:\\b.jpeg");//没有这张图片，路径不存在
		Long l2 = f2.length();
		System.out.println(l2);//返回为0
		File f3 = new File("D:\\Hello java");//文件夹没有大小概念的
		Long l3 = f3.length();
		System.out.println(l3);
		
	}
}

---

过滤器

我们可以使用过滤器来实现
在File类中有两个ListFiles重载的方法，方法参数传递的就是过滤器。
File[] ListFiles(FileFilter filter)
java.io.FileFilter接口:用于抽象路径名(File对象)的过滤器，
用来过滤文件
boolean accept(File pathname) 测定抽象路径名是否包含在某个路径名列表中
pathname使用ListFiles方法遍历目录得到的每一个文件对象
File[] ListFiles(FilenameFilter filter)
java.io.FilenameFilter接口，过滤文件名称
boolean accept(File dir,String name) 测试指定文件是否应该包含在某一列表中
File dir:构造方法中传递的被便利的目录
String name:使用ListFiles方法遍历目录，获取每一个文件/文件夹的名称
注意:
两个过滤器接口是没有实现类的，需要我们自己写实现类，重写过滤的方法accept
在方法中自己定义过滤的规则。
==================

public class FilterTest {

	public static void main(String[] args) {
		File file = new File("D:\\1907testjava\\day01");
		getAll(file);
	}
	//参数file类型的目录
	public static void getAll(File dir){
		
		File[] files = dir.listFiles(new FileFilterImpl());//传递过滤器
		for (File f : files) {
			if(f.isDirectory()){
				//递归调用
				getAll(f);
			}else{
			System.out.println(f);
			}
		}
	}
}

--------------------------------
import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;

/*
 * 	我们可以使用过滤器来实现
 * 		在File类中有两个ListFiles重载的方法，方法参数传递的就是过滤器。
 * 			File[] ListFiles(FileFilter filter)
 * 				java.io.FileFilter接口:用于抽象路径名(File对象)的过滤器，
 * 				用来过滤文件
 * 				boolean accept(File pathname) 测定抽象路径名是否包含在某个路径名列表中
 * 				pathname使用ListFiles方法遍历目录得到的每一个文件对象
 * 			File[] ListFiles(FilenameFilter filter)
 * 				java.io.FilenameFilter接口，过滤文件名称
 * 				boolean accept(File dir,String name) 测试指定文件是否应该包含在某一列表中
 * 				File dir:构造方法中传递的被便利的目录
 * 				String name:使用ListFiles方法遍历目录，获取每一个文件/文件夹的名称
 * 
 * 		注意:
 * 			两个过滤器接口是没有实现类的，需要我们自己写实现类，重写过滤的方法accept
 * 		在方法中自己定义过滤的规则。
 * 
 */
public class FilterTest02 {

	public static void main(String[] args) {
		File file = new File("D:\\1907testjava\\day01");
		getAll(file);
	}
	//参数file类型的目录
	public static void getAll(File dir){
		//传递过滤对象，使用匿名内部类
		/*File[] files = dir.listFiles(new FileFilter() {
			//不用实现类，使用匿名对象
			@Override
			public boolean accept(File pathanme) {
				// 过滤规则
			return pathanme.isDirectory() ||pathanme.getName().toLowerCase().endsWith(".java");
				
			}
		});*/
		/*File[] filex = dir.listFiles((File pathname)->{
			return pathname.isDirectory() ||pathname.getName().toLowerCase().endsWith(".java");
		});*/
		File[] filex = dir.listFiles(pathname->pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java"));
		
		//地热种方法匿名内部类过滤
		/*File[] files = dir.listFiles(new FilenameFilter() {
			
			@Override
			public boolean accept(File dir, String name) {
				// TODO Auto-generated method stub
			return new File(dir,name).isDirectory() ||name.toLowerCase().endsWith(".java");
			}
		});*/
		
		//使用Lambda表达式优化匿名内部类（接口中只有一个抽象方法才能使用Lambda表达式）
		File[] files = dir.listFiles((File d,String name)->{
			return new File(d,name).isDirectory() ||name.toLowerCase().endsWith(".java");
		});
		
		//继续简化
//		File[] filess = dir.listFiles(( d, name)->new File(d,name).isDirectory() ||name.toLowerCase().endsWith(".java"));
		
		
		//传递过滤器
		for (File f : files) {
			if(f.isDirectory()){
				//递归调用
				getAll(f);
			}else{
			System.out.println(f);
			}
		}
	}
}

----------------------------
import java.io.File;
import java.io.FileFilter;

/*
 * 	创建过滤器FileFilter的实现类,重写过滤方法
 * 	定义过滤规则
 * 		
 * 
 */
public class FileFilterImpl implements FileFilter{

	@Override
	public boolean accept(File pathname) {
		// 返回的结果存储到File数组之中
		//在accept方法中是否以.java结尾，是返回true,不是返回falses
		if(pathname.isDirectory()){
			//把文件夹也放在数组之中继续遍历。
			return true;
		}
		return pathname.getName().toLowerCase().endsWith(".java");
	}

}