Java基础---Java---IO流-----File 类、递归、删除一个带内容的目录、列出指定目录下文件夹、FilenameFilte

File 类

用来将文件或者文件夹封装成对象

方便对文件与文件夹进行操作。

File对象可以作为参数传递给流的构造函数

流只用操作数据，而封装数据的文件只能用File类



File类常见方法：

1.创建

boolean createNewFile():在指定位置创建文件。如果该文件已经创建，则不创建。

2.删除

boolean delete();删除失败，返回false

void deleteOnExit();在程序退出时，删除指定文件。

3.判断

boolean exists().测试此抽象路径名表示的文件或目录是否存在。

boolean mkdir():创建文件夹

boolean mkdirs():创建多级文件夹

isFile();

isDirectory();

isHidden();

isAbsolute();

4.获取信息

getName();

getPath();//相对路径文件

getAbsoluteFile()//返回的是对象

getAbsolutePath()//返回的是字符串

getParent(); //如果没有明确的指定它的路径，则返回一个null

lastModified();

length();

import java.io.*;
class FileDemo{
	public static void main(String[]args)throws IOException{
		ConsMethod();
		method_1();
		method_2();
		method_3();
		method_4();
		method_5();
	}

	public static void method_1()throws IOException{
		File f=new File("file.txt");
		sop("create"+f.createNewFile());//sop在文件操作中相当于打印(System.out);
		f.delete(OnExit());
		sop("delete"+f.delete());
	}
	public static void method_2()throws IOException{
		File f=new File("FileDemo.java");
		sop("execute"+f.canExecute());//判断文件是否可执行
		//创建文件夹
		File dir=new File("abc");
		sop("mkdir"+dir.mkdir());
	}
	public static void method_3()throws IOException{
		File f=new File("FileDemo.java");
		f.createFile();
		//记往在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在。通过exists判断。
		sop("dir"+f.isDirectory());
		sop("dir"+f.isFile());
	}
	public static void method_4()throws IOException{
		File f=new File("file.txt");

		sop("path"+f.getPath());
		sop("abpath"+f.getAbsolutePath());
		sop("parent"+f.getParent());//这个方法返回的是绝对路径下的父目录。如果是相对，则返回null
	}
	public static void method_5()throws IOException{
		File f1=new File("c:\\Test.java");
		File f2=new File("d:\\sf.java");
		sop("rename"+f1.renameTo(f2));//返回的是true或false,这种方法类似剪切。移动。。
	}

	public static void ConsMethod(){
		//将a.txt封装成file对象，可以将已有的和为出现的文件或者文件夹
		File f1=new File("a.txt");
		File f2=new File("c:\\abc","b.txt");
		File f4=new File("c:"+File.separator+"abc\\zzz\\a.txt");//目录分隔符
	}
}

FilenameFilter:这是一个接口，实现此接口的类实例可用载过滤文件名

import java.io.*;
class FileDemo2{
	public static void main(String[] args){
		listRootsDemo();
		listDemo();
		File dir=new File("d:\\Programfiles\\");
		String[] arr=dir.list(new FilenameFilter(){
			public void accept(File dir,String name){
				//System.out.println("dir:"+dir+"...name::"+name);
				//return false;
				return name.endWith(".bmp");
			}
		});//传递一个匿名内部类
		for(String name:arr){
			System.out.println(name);//
		}
	}
	public static void listRootsDemo(){
		File[] files=File.listRoots();
		for(File f:files){
			System.out.println(f);
		}
	}
	public static void listsDemo(){
		File[] files=new File("c:\\");
		String [] names=f.list();//调用list方法的file对象必须是封装了一个目录，该目录还必须存在。
		for(String name:names){
			System.out.println(name);
		}
		for(File f:files){
			System.out.println(f);
		}
	}
}

列出指定目录下文件夹或者文件夹，包含子目录中的内容。也就是指定目录下所有内容。因为目录中还有目录，只要使用同一个列出目录的功能函数完成即可。

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

这种表现形式的手法，称为递归。

递归要注意：

1.限定条件。

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

import java.io.*;
class FileDemo{
	public static void main(Stirng[] args){
		File dir=new File("d:\\Programfiles");
		showDir(dir);
		toBin(6);

	}

	public static void toBin(int num){
		while(num>0){
			toBin(num/2);
			System.out.println(num%2);

		}
	}

	public static void showDir(File dir){
		System.out.println(dir);
		File[] files=dir.listFiles();
		for(int x=0;x<files.length();x++){
			if(files[x].isDirectory())
			showDir(files[x]);//如果判断是子目录，则再调用showdir
			else
			System.out.println(files[x);
		}
	}
}showA();

void showA(){
	showB();
	sop(A);
}
void showB(){
	showC();
	sop(B);
}
void showC(){
	sop(C);
}

<span style="font-size:18px;color:#ff0000;"><strong>列出目录下所有的内容。</strong></span>

import java.io.*;
class FileDemo3{
	public static void main(Stirng[] args){
		File dir=new File("d:\\Programfiles");
		showDir(dir);

	}
	public static String getLevel(int level){
		StringBuilder sb=new StringBuilder();
		for(int x=0;x<level;x++){
			sb.append(" ");
		}
		return sb.toString();
	}

	public static void showDir(File dir(int level)){
		System.out.println(getLevel(level)+dir.getName());
		level++;
		File[] files=dir.listFiles();
		for(int x=0;x<files.length();x++){
			if(files[x].isDirectory())
			showDir(files[x],level);//如果判断是子目录，则再调用showdir
			else
			System.out.println(getLevel(level)+Files(x));
		}
	}
}

删除一个带内容的目录

删除原理:

在window中，删除目录从里面住外删除的。

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

删除的文件不会出现在回收站里



import java.io.*;

class removeDir{

public static void main(String[] args){

File dir=new File("d:\\testDir");

remove(dir);

}

public static void remove(File dir){

File[] files=dir.listFiles();

for(int x=0;x<files.length;x++){

if(!files[x].isHidden()&&files[x].isDirectory())

remove(files[x]);

else

System.out.println(files[x].toString()+"-file-"+files[x].delete());//删除的时候打印一下，就要以看到是否重删等



}

System.out.println(dir.toString()+"-dir-"+dir.delete());

}

}



思路：

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

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

3.将这些路径存诸到集合中。

4.将集合中的数据写入到一个文件夹中

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class javaFileList {

	public static void main(String[] args) throws IOException{
		File dir=new File("d:\\java1223");
		List<File> list=new ArrayList<File>();
		fileToList(dir,list);
		System.out.println(list.size());
		File file=new File(dir,"javalist.txt");
		writeToFile(list, file.toString());

	}
	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"))//如果判断扩展名是.java，则加入文件集合
				list.add(file);
			}
		}
	}

	public static void writeToFile(List<File> list,String javaListFile)throws IOException{
		BufferedWriter bufw=null;

		try {
			bufw=new BufferedWriter(new FileWriter(javaListFile));
			for(File f:list){
				String path=f.getAbsolutePath();
				bufw.write(path);
				bufw.newLine();
				bufw.flush();
			}

		} catch (Exception e) {
			throw e;//这样扔的话，必须在上面标识IO异常
		}
		finally{
			try {
				if(bufw!=null)
					bufw.close();
			} catch (Exception e2) {
				throw e2;
			}
		}
	}
}