JAVA常用类（十一）：File类

目录

File类：

构造方法：

成员方法：

过滤器的使用：

高级获取遍历文件：

递归遍历文件的操作：

---

File类：

文件和目录(文件夹)路径名的抽象表示形式。 ----------  仅仅是一个路径的表示，不代码具体的事物一定是存在的。( IO流的基础 )

文件：本质上存储二进制码。.txt表示以文本来翻译，后缀名表示选择哪种解析方式。

构造方法：

public File（String  pathname）；

public File（String parent , String child）；

public File( File parent , String child）；

注：使用File类实例化的对象，是不能确定它是文件还是目录（文件夹），在文件存在的情况下需要使用isFile/isDirection方法进行判断。同时构造方法中的文件名可以随意创建，但是否存在是依靠exists()方法判断的。

import java.io.File;
public class FileDemo1 {
	public static void main(String[] args) {
		File f = new File("G:\\图片\\050.jpg");  //构造方法中的文件名可以随意创建，但是否存在是依靠方法判断的。
		File f1 = new File("G:/图片");
		
		File f2 = new File("G:/图片","050.jpg");
		
		File f3 = new File(f1,"050.jpg");
	}
}

成员方法：

创建：

public boolean createNewFile()  ----------- 创建新文件，返回true则创建成功，反之失败。若已存在同名文件，则返回false

public boolean mkdir() -----------------------  创建单级目录的文件夹，即只能创建一层不存在目录。

public boolean mkdirs() ---------------------  创建多级目录的文件夹，即创建多层不存在目录。

删除：

public boolean delete() -----------------------  删除单个文件/目录：若文件夹(目录)下包含内容，则删除失败。

重命名：

public boolean renameTo(File dest) -----  对文件/夹重命名，本质是文件的移动。

注：File类创建对象是不区分文件和目录的，只有通过mkdir(s)方法创建的才是目录，使用creatNewFile()方法创建的才是文件，与是否有后缀无关，后缀名只是告诉程序默认使用那种方式来解析文件

import java.io.File;
import java.io.IOException;
public class FileDemo2 {
	public static void main(String[] args) {
		File f = new File("G:\\图片\\050.jpg");
		try {
			boolean b = f.createNewFile();
			System.out.println(b);   //false,存在已有同名文件则显示创建失败
			//目录==文件夹
			File f2 = new File("G:\\a\\b");
			f2.mkdir();
			File f3 = new File("G:/a/ab/c"); //代表的是c这个文件夹
			f3.mkdirs();
			
			File f4 = new File("G:/456");
			f4.createNewFile();
			File f5 = new File("G:/789.txt");
			f5.mkdir();
			
			f4.delete();
			f3.delete();  //删除的是c这个文件夹
			f2.delete();  //如果文件夹中有内容时删除不了的（a文件夹下有内容）
			
			f5.renameTo(new File("G:/a/门神.jpg"));  //重命名的本质是：文件的移动
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

判断：

public boolean isDirectory() ---------------------------- 判断是否是一个文件夹/目录

public boolean isFile() ------------------------------------ 判断是否是一个文件

public boolean exists() ----------------------------------- 判断文件/夹是否存在

public boolean canRead() ------------------------------- 判断文件/夹是否可读

public boolean canWrite() ------------------------------  判断文件是否可写

public boolean isHidden() ------------------------------ 判断文件/夹是否隐藏

public class FileDemo3 {
	public static void main(String[] args) {
		//构造方法中的文件名可以随意创建，但是否存在是依靠方法判断的。
		File f = new File("djasd");
		System.out.println(f.exists());  //false
		//G:/图片/050.jpg 该路径存在
		File f1 = new File("G:/图片/050.jpg");
		System.out.println(f1.isDirectory()); //false
		System.out.println(f1.isFile());  //true
		System.out.println(f1.canRead());  //true
		//文件--右键--属性
		System.out.println(f1.canWrite()); //true
		System.out.println(f1.isHidden()); //false
	}
}

获取：

public String getAbsolutePath()  -------------------------- 获取文件的绝对路径（比较常用）

public String getPath() --------------------------------------- 获取文件的相对路径

public String getName() ------------------------------------- 获取文件的名称（比较常用）

public long length() ------------------------------------------- 获取文件的容量大小（占用字节），若是文件夹则返回不确定值

public long lastModified() ---------------------------------- 获取最后的修改时间（毫秒值）

public class FileDemo4 {
	public static void main(String[] args) throws IOException {
		File f = new File("G:\\图片\\Pictures\\125.jpg");
		System.out.println(f.exists());  //true
		System.out.println(f.getAbsolutePath()); //G:\图片\Pictures\\125.jpg
		System.out.println(f.getPath());  //G:\图片\Pictures\\125.jpg
		System.out.println(f.getName());  //125.jpg
		
		File f2 = new File("002.txt"); 
		System.out.println(f2.createNewFile());  //true
		//D:\developSoftware\workspace\java\javase05\javase05\002.txt -- 绝对路径
		System.out.println(f2.getAbsolutePath()); 
		//002.txt -- 相对路径  --  默认的基准路径eclipse工作空间项目路径
		System.out.println(f2.getPath());
		
		File f3 = new File("G:\\图片\\Pictures\\125.jpg");
		System.out.println(f3.length()); //3162813
		System.out.println(f3.lastModified()); //1526287442000 获取最后修改时间
		Date d = new Date(f3.lastModified());
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		System.out.println(sdf.format(d)); //2018-05-14
	}
}

高级获取：针对文件夹（包含子文件）----------------- 是遍历文件的一种方法（另一种是递归）

public String[ ] list()  ------------------ 将所有的子文件字符串放入字符串数组中

public File[ ] listFiles() --------------- 将所有的子文件对象放入File数组中，更加常用，listFiles()的重载方法包含两种过滤器

public class FileDemo5 {
	public static void main(String[] args) {
		File f1 = new File("G:/图片");
		String[] list = f1.list();
		for(String s:list) {
			System.out.println(s);
		}
		System.out.println("======================");
		File[] listFiles = f1.listFiles();  //listFiles()返回对象数组，使用范围更广一些
		for (File f : listFiles) {
			System.out.println(f);  //直接以字符串的形式输出对象的属性信息，File类重写了toString方法
		}
	}
}

过滤器的使用：

public File[ ] listFiles ( FilenameFilter  filter）------------  重写accept(File dir, String name)：dir 文件夹    name 文件名

public File[ ] listFiles ( FileFilter  filter） -------------------  重写 accept(File pathname) ：pathname为绝对路径的File类对象

实现过滤器FilenameFilter / FileFilter接口的对象可以过滤文件，重写accept()方法，将判断条件写在返回值上，返回true则不过滤，返回false则过滤。相较于直接使用listFiles()，listFiles( 过滤器接口对象 )的效率要更高一些。------- 使用见下一节案例

高级获取遍历文件：

案例：单级目录下是否有后缀名为.jpg的文件，如果有，就输出此文件名称。  ------------  四种方法实现

public class Demo03 {
	public static void main(String[] args) {
		findFiles("G:/图片",".jpg");
		findFiles2("G:/图片",".jpg");	
	}
	//list()方法不能解决文件夹名包含后缀的情况，因此使用第二种遍历方式
	public static void findFiles(String path,String filename) {
		File f = new File(path);
		String[] list = f.list();
		String s1 = filename;
		for (String s : list) {
			if(s.toLowerCase().endsWith(s1.toLowerCase())) {
				System.out.println(s);
			}	
		}
	}
	//listFiles()返回File类型的数组，能够调用File类的成员方法，因此更常用一些。
	public static void findFiles2(String path,String filename) {
		//1.把路径转为File对象
		File f = new File(path);
		//2.获取所有子文件
		File[] list = f.listFiles();
		//遍历这个文件夹
		if(list!=null && list.length>0) {  //首先判断File[]是否为空，此时不能使用&，当File[]为空时调用.length方法容易出现空指针异常
			for (File file : list) {
				//file.isFile()判断是否是文件，toLowerCase()都转成小写，以此来解决区分大小写问题
				if(file.isFile() && file.getName().toLowerCase().endsWith(filename.toLowerCase()))
					System.out.println(file.getAbsolutePath());
			}
		}
	}
	//使用过滤器来遍历
	public static void findFiles3(String path,String suffix) {
		//1.把路径封装成File
		File f = new File(path);
		//2.使用过滤器获取子文件/夹
		File[] listFiles = f.listFiles(new FilenameFilter() {	
			/**
			 * dir：文件夹   -- G:/图片
			 * name:每一个文件的名字
			 */
			@Override
			public boolean accept(File dir, String name) {
				//newFile为绝对路径的File对象
				File newFile = new File(dir,name);
				if(newFile.isFile() && name.toLowerCase().endsWith(suffix.toLowerCase())) {
					System.out.println(newFile.getAbsolutePath());
					return true;  //true表示存入
				}
				return false; //false表示不存入
			}
		});
	}
	public static void findFiles4(String path,String suffix) {
		//1.把路径封装成File
		File f = new File(path);
		//2.使用过滤器获取子文件/夹
		File[] listFile = f.listFiles(new FileFilter() {		
			@Override
			public boolean accept(File pathname) {
				if(pathname.isFile() && pathname.getName().toLowerCase().endsWith(suffix.toLowerCase())) {
					System.out.println(pathname.getAbsolutePath());
					return true;  //true表示存入
				}
				return false;
			}
		});
	}
}

递归遍历文件的操作：

案例：递归遍历目录下指定后缀名结尾的文件名称

1.把路径包装成File类对象f；

2.判断 f 是文件还是文件夹：文件 ------ 判断是否以后缀名结尾

                                             文件夹 --- 拿到所有的子文件；转成字符串逐个传入本方法中进行递归调用

public class Demo02 {
	public static void main(String[] args) {
		findAllFiles("G:/图片",".jpg");
	}
	public static void findAllFiles(String path,String suffix) {
		//1.把path包装成File
		File f = new File(path);
		//2.判断f是文件夹还是文件
		if(f.isFile()) {  //文件
			//判断是否是suffix结尾：
			if(f.getName().toLowerCase().endsWith(suffix.toLowerCase())) {
				System.out.println(f.getAbsolutePath());
			}
		}else {    //文件夹
			//拿到所有的子文件
			File[] fileList = f.listFiles();
			if(fileList!=null && fileList.length>0) {  //
				//遍历
				for (File file : fileList) {
					//递归调用
					findAllFiles(file.getAbsolutePath(),suffix);
				}
			}
		}
	}
}

案例：递归删除一个带内容的文件夹（带内容的文件夹不可直接删除）

1.将路径包装成File类对象f；

2.判断f是文件还是文件夹：文件 ---- 删除

                                            文件夹 ---- 获取所有的子文件，进行递归判断，直至删除文件夹下所有的子文件

3.最后把自己的文件夹删掉。

public class Demo03 {
	public static void main(String[] args) {
		deleteAllFiles("h:/temp");
	}
	public static void deleteAllFiles(String path) {
		//1.把path包装成File
		File f = new File(path);
		//2.判断 是文件还是文件夹
		if(f.isFile()) {  //文件
			f.delete();
		}else {  //文件夹
			File[] file = f.listFiles();
			//递归删除文件夹中的子文件
			if(file!=null && file.length>0) { //file!=null防止出现空指针异常；file.length>0判断是否有文件存在
				for (File file2 : file) {
					deleteAllFiles(file2.getAbsolutePath());
				}
			}
		}
		//最后把自己删除掉
		f.delete();
		System.out.println("删除成功！");
	}
}