Java中的文件操作API-File

文件操作-File

java.io.File

input output 输入与输出

File用于文件系统中一个文件或目录的

使用File我们可以：（可以进行以下操作，但是不能访问文件数据，可以通过其他类的方法访问）

1.访问其表示的文件或目录的属性（名字、大小等）

​ File对象.getName(); 获取文件名

​ File对象.length(); 获取文件长度（即文件的大小，单位是字节，返回值是long类型）

​ 学会用API查看每个类对应的方法

路径有两种：绝对路径和相对路径

在访问文件时，尽可能不要写绝对路径，绝对路径虽然清晰明了，
但绝对路径不可变，不会跟随项目文件夹的路径变化而变化，无法做到跨平台

建议使用相对路径，相对路径不能直观体现出实际位置，但是灵活并适应各种不同的运行环
在eclipse中，我们用 " . / " 表示当前目录（当前程序所在项目的目录）

import java.io.File;
public class FileDemo {
	public static void main(String[] args) {
		//创建file实例
		//尽可能不要写绝对路径
		//File file = new File("D:/jsd190602yxt/jsd1906yxtSE/demo.txt");
		//绝对路径不可变，不会跟随项目文件夹的路径变化而变化
		//建议使用相对路径，"."表示当前目录（在哪个项目的运行环境，当前程序所在项目的目录）
		File file = new File("./demo.txt");
		
		//获取文件名
		String name = file.getName();
		System.out.println(name);
		
		//获取文件长度（即文件的大小，单位是字节，返回值是long类型）
		long len = file.length();
		System.out.println(len+"字节");
		
		//获取文件绝对路径
		String path = file.getAbsolutePath();
		System.out.println(path);
		
		//查看文件可读、可写、隐藏（API中查看其他方法）
		boolean cr = file.canRead();
		boolean cw = file.canWrite();
		boolean ih = file.isHidden();
		System.out.println("可读："+cr);
		System.out.println("可写："+cw);
		System.out.println("隐藏："+ih);
	}
}

2.创建，删除文件或目录

创建文件

file.createNewFile();
File类对象先传参（需要创建的文件路径及名字包括后缀）实例化，再调用该方法

//CreateNewFileDemo.java
import java.io.File;
import java.io.IOException;
public class CreateNewFileDemo {
	public static void main(String[] args) throws IOException {
		/*
		 * 在当前项目目录下新建一个文件test.txt
		 */
		//需要先实例化一个对象，传入需要创建的路径
		File file = new File("./test.txt");
		//注意创建文件前要先判断该文件是否已经存在
		if(!file.exists()){
			//注意这里需要抛出异常，文件访问可能发生异常
			file.createNewFile();
			System.out.println("文件已成功创建！");
		}else{
			System.out.println("创建失败，文件已经存在！");
		}
	}
}

删除文件

file.delete();
File类对象先传参（需要删除文件的路径）实例化，再调用该方
注意千万别误删其他文件，这是直接删除，回收站都没有的

//DeleteFileDemo.java
import java.io.File;
public class DeleteFileDemo {
	public static void main(String[] args) {
		/*
		 * 将当前目录下，刚才创建的test.txt
		 */
		File file = new File("./test.txt");
		//与创建一样，先判断文件存不存在
		if(file.exists()){
			//删除文件，注意千万别误删其他文件，这是直接删除，回收站都没有的
			file.delete();
			System.out.println("文件删除成功！");
		}else{
			System.out.println("文件不存在，不用删除");
		}
	}
}

创建目录

dir.mkdir();

File类对象先传参（需要创建的目录路径）实例化，再调用该方法

import java.io.File;
public class MkdirDemo {
	public static void main(String[] args) {
		/*
		 * 在当前目录下创建一个名为demo的目录
		 */
		File dir = new File("./demo");      
		//创建目录也需要判断目录是否存在
		if(!dir.exists()){
			//注意mkdir()方法要求当前创建目录的父目录必须存在
			dir.mkdir();
			System.out.println("成功创建目录！");
		}else{
			System.out.println("创建失败，目录已存在！");
		}
	}
}

创建多级目录

dirs.mkdirs();

mkdir()方法要求当前创建目录的父目录必须存在；
而mkdirs()方法可以创建多级目录，若上述父目录没有，则将会被创建

File 的 mkdirs 方法用于创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
**注意：**此操作失败时，也可能已经成功地创建了一部分必需的父目录。

boolean mkdirs() 返回值：当且仅当已创建目录以及所有必需的父目录时，返回true ；否则返回false

import java.io.File;
public class MkdirsDemo {
	public static void main(String[] args) {
		/*
		 * 在当前目录下创建一个多级目录：
		 * a/b/c/d/e/f
		 */
		File dirs = new File("./a/b/c/d/e/f");
		if(dirs.exists()){
			//dirs.mkdir();  //注意mkdir()方法要求当前创建目录的父目录必须存在
			//mkdirs()方法可以创建多级目录，若上述父目录没有，则将会被创建
			dirs.mkdirs();
			System.out.println("成功创建目录！");
		}else{
			System.out.println("创建失败，目录已存在！");
		}
	}
}

目录的删除

注意 delete(); 方法在删除目录时，需要保证该目录是一个空目录

import java.io.File;
public class DeleteDirDemo {
	public static void main(String[] args) {
		/*
		 * 将创建的目录删除
		 */
		File dir = new File("./demo");
		if(dir.exists()){
			dir.delete(); //注意该方法在删除目录时，需要保证该目录是空目录
			System.out.println("目录成功删除！");
		}else{
			System.out.println("目录不存在，无需删除");
		}
	}
}

如需删除多级目录，即非空目录，我们需要先进行访问目录中的子项，删除所有子项后再删除当前目录

如下：第三点

3.访问一个目录中的子项

在进行访问子项前，我们需要先判断当前File对象是目录还是文件
boolean isFile(); 判断当前File表示的是否为文件
boolean isDirectory(); 判断当前File表示的是否为目录

通过下面方法访问一个目录中的子项

1. File[] listFiles(); 返回一个File的数组，里面存着该目录的所有子项

import java.io.File;
public class ListFileDemo {
	public static void main(String[] args) {
		//获取当前目录中的所有子项
		File dir = new File(".");
		//先判断是不是目录
		if(dir.isDirectory()){
			//如果是目录的话，
			//创建一个File数组存放listFiles()方法返回的子项列表
			File[] subs = dir.listFiles();
			//遍历子项数组，输出其名字
			for(File f: subs){
				System.out.println("该目录的子项为：");
				System.out.println(f.getName());
			}
		}else if(dir.isFile()){
			System.out.println("当前File为文件");
		}
	}
}

根据上述，我们重新来看，如何删除非空目录

递归删除非空目录

package file;
import java.io.File;
/**
 * 删除时首先判断file表示的是否为目录
 * 若是文件直接删除，
 * 若是目录则获取当前目录的子项
 * 再对子项判断，若是文件直接删除....
 * @author Tian
 *
 */
public class Test {
	public static void main(String[] args) {
		File dir = new File("./a");
		delete(dir);
	}
    
	public static void delete(File file){
		//先判断文件存不存在
		if(file.exists()){
			//判断是不是目录
			if (file.isDirectory()) {				
                //清空目录
				//遍历当前目录，如果该目录有子目录，递归调用delete方法自己本身
				for (File f : file.listFiles()) {
					delete(f);
				}
			}
			file.delete();
			System.out.println("成功删除文件："+file.getName());
		}else{
			System.out.println("文件不存在，无需删除");
		}
	}
	
//	//失败的方法，运行一次只能删最底层的文件，要删多少层就需要运行多少次
//	public static void delete(File file){
//		//先判断文件存不存在
//		if(file.exists()){
//			//判断file是不是文件
//			if(file.isFile()){
//				file.delete();
//			}else if(file.isDirectory()){ //判断file是不是目录
//				//删除空目录，如果失败说明目录非空，遍历目录递归调用delete
//				if(file.delete()){ 
//					System.out.println("成功删除文件："+file.getName());
//				}else{
//					//获取
//					File[] subs = file.listFiles();
//					for(File fs:subs){
//						delete(fs);
//					}
//				}
//			}
//		}else{
//			System.out.println("文件不存在，无需删除");
//		}
//	}
}

递归调用：方法内部自己调用自己
注意：在实际开发中，递归能不用就不用，
递归要：避免死循环，递归层数不能太高，层数太多会对影响性能和资源开销

2. File[] listFiles(FileFilter filter) 获取一个目录下指定的子项

将目录中符合过滤器要求的子项获取
该方法，需要自己定义一个过滤器的类，实现过滤器的接口，自己定义过滤方式

该过滤器类建议使用匿名内部类实现

代码如下：

import java.io.File;
import java.io.FileFilter;
public class ListFilesDemo {
	public static void main(String[] args){
		/*
		 * 获取当前目录中所有名字以“.”开头的内容
		 */
		File dir = new File(".");
		//先判断是不是个目录
		if(dir.isDirectory()){
			//实例化一个过滤器对象
			//该类需要自己定义，实现接口中的方法
			//Myfilter filter = new Myfilter();
			//建议使用匿名内部类方式，因为该类只被使用一次，不需要单独一个类
			//匿名内部类方式书写
			FileFilter filter = new FileFilter(){
				//重写接口中的过滤方法
				@Override
				public boolean accept(File file) {
					//获取文件名
					String name = file.getName();
					//查看过滤过程，观察回调模式
					System.out.println("正在过滤："+name);
					//判断文件名是否以" . "开头
					//返回判断后的结果
					return name.startsWith(".");
				}
			};
			//回调模式，遍历了数组，对其中每个子项进行过滤
			//传入过滤器，获取符合要求的子项，存入子项数组
			File[] subs = dir.listFiles(filter);
			//输出子项个数
			System.out.println(subs.length);
			//循环遍历输出子项名字
			for(File f:subs){
				System.out.println(f.getName());
			}
		}else{
			System.out.println("不是目录，无法访问！");
		}
	}
}
///**
// * 定义一个类实现过滤器(该类可以写在main方法中，使用匿名内部类)
// */
//class Myfilter implements FileFilter{
//	//重写接口中的过滤方法
//	@Override
//	public boolean accept(File file) {
//		//获取文件名
//		String name = file.getName();
//		//查看过滤过程，观察回调模式
//		System.out.println("正在过滤："+name);
//		//判断文件名是否以" . "开头
//		//返回判断后的结果
//		return name.startsWith(".");
//	}
//}