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;
}
}
}
}