【IO流】File类及递归算法访问文件

1. File类

• File类的对象表示了磁盘上的文件或目录
• File类提供了平台无关的方法对磁盘上的文件或目录进行操作
• File类直接处理文件和文件系统，比如删除文件，获取文件长度大小等信息
• File类没有提供方法从文件读取或向文件存储信息

2. 方法摘要

2.1 构造方法

• File(String directoryPath)
• File(String directoryPath, String filename)
• File(File dieObj, String filename)

2.2 获取File对象标准属性

• public String getName()
• public String getParent()
• public File getParentFile()
• public String getAbsolutePath()
• public boolean exists()
• public File[] listFiles()
• public boolean isDirectory()
• public boolean isFile()
• public long length()
• boolean delete()
• boolean mkdir()

2.3 列出指定目录下的文件目录方法

• String[] list()：返回目录中文件或目录的名称
• String[] list(FilenameFilter filter)：返回目录中满足指定名称过滤器条件的文件或目录的名称
• File[] listFiles()：返回目录中文件或目录的File对象
• File[] listFiles(FileFilter filter)：返回目录中满足指定文件过滤器条件的文件或目录的File对象
• File[] listFiles(FilenameFilter filter)：返回目录中满足指定名称过滤器条件的文件或目录的File对象

2.4 过滤器

interface FilenameFilter{
    accept(File dir, String name);
    //dir:被找到的文件所在的目录
    //name：文件的名称
 }

interface FileFilter{
    accept(File pathname);
    //pathname：要测试的抽象路径名
 }

3. Code Demo

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

public class FileDemo {

    public static void main(String[] args) {

        File file=new File("E:\\JAVAstudy\\JavaTest");//window下的盘符为\\，Linux下的盘符为/
        //获取文件的标准属性
        System.out.println(file.exists());
        System.out.println(file.getAbsolutePath());
        System.out.println(file.getParent());
        System.out.println(file.isDirectory());
        System.out.println(file.isFile());
        System.out.println(file.length());
        System.out.println(file.delete());//只有空目录才能删除

        //创建文件夹目录
        File myFile=new File("E:\\JAVAstudy\\JavaTest\\myFile");
        System.out.println(myFile.mkdir());

        //创建空文件
        File myFile2=new File("E:\\JAVAstudy\\JavaTest\\myFile。txt");
        //createNewFile()会抛出一个IOException。因为可能要创建的文件已存在，创建会失败。
        try {
            System.out.println(myFile2.createNewFile());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        //获取指定目录下的所有文件名和目录名
        String[] fileList1=file.list();//无参的list()方法
        for(String name:fileList1){
            System.out.println(name);
        }

        //获取指定目录下满足指定文件（目录）过滤条件的文件或目录
        //过滤条件通过创建一个匿名内部类FilenameFilter对象，对接口的的accept()方法进行重写
        String[] fileList2=file.list(new FilenameFilter(){//使用带有过滤器的list方法
            @Override
            public boolean accept(File file,String name){
                return name.endsWith(".pdf");//过滤pdf文件
            }   
        });
        for(String name:fileList2){
            System.out.println(name);
        }

        //获取指定目录所有文件或目录的大小
        File[] fileList3=file.listFiles();
        for(File f:fileList3){
            System.out.println(f.getName()+": "+f.length());
        }

        //获取指定目录下满足指定文件（目录）过滤条件的文件或目录
        //过滤条件通过创建一个匿名内部类FileFilter对象，对接口的的accept()方法进行重写
        File[] fileList4=file.listFiles(new FileFilter(){//使用带有过滤器的list方法
            @Override
            public boolean accept(File file){
                return file.canWrite();//过滤可读写文件
            }   
        });
        for(File f:fileList4){
            System.out.println(f.getName());
        }
    }
}

4. 递归算法访问文件和目录

4.1 递归算法：

一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，通常把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题求解。

递归策略之需要销量的代码就能描述出解题过程中所需要的多次重复计算

4.2 递归算法注意事项：

• 递归就是在过程或函数中调用自身
• 在使用递归策略时，必须有一个明确的递归结束条件，成为递归出口

4.3 求一个数的阶乘：

public int getFac（int number）{
     if(number==1){
          return 1; 
     }else{
          return number*getFac(number-1);
     }
}

4.4 递归算法访问文件和目录：

案例介绍：

给定一个目录，要求按层次显示目录结构信息，文件名后面加上“\”表示是文件夹。

案例设计：

• 使用递归算法
• 使用File类中的listFile方法遍历文件夹
• 使用List集合

import java.io.File;
import java.util.ArrayList;
import java.util.List;


public class IteratorDirDemo {

    public static void main(String[] args) {
        IteratorUtil.IteratorDir(new File("path"));
    }

}
class IteratorUtil{
    private static int level=0;//表示目录的层级
    public static void IteratorDir(File file){
        if(file!=null){
            //找到递归出口
            if(file.isFile()||file.listFiles().length==0){
                return;//如果是文件或者空文件夹就返回。
            }else{
                File[] files=file.listFiles();
                //先输出目录，在输出文件
                files=sort(files);
                for(File f:files){
                    StringBuilder sb=new StringBuilder();
                    if(f.isFile()){
                        //把文件名分级放入sb中
                        sb.append(getTab(level));
                        sb.append(f.getName());
                    }else{
                        //把目录名反别放入sb中
                        sb.append(getTab(level));
                        sb.append(f.getName());
                        sb.append("\\");//第一个\是转义字符
                    }
                    System.out.println(sb.toString());
                    //假如是目录，进入目录遍历，层级加一
                    if(f.isDirectory()){
                        level++;
                        IteratorDir(f);//递归调用文件夹内的文件夹
                        level--;//返回上一级，打印没有打印的文件文件夹
                    }
                }
            }
        }
    }
    /**
     * 对文件File类型的数组进行先目录后文件的排序
     * @param files
     * @return
     */
    private static File[] sort(File[] files){

        List<File> fileList=new ArrayList<File>();
        for(File f:files){
            if(f.isDirectory()){
                fileList.add(f);
            }
        }
        for(File f:files){
            if(f.isFile()){
                fileList.add(f);
            }
        }
        //把集合中的元素转换成指定大小和指定类型的数组
        return fileList.toArray(new File[fileList.size()]);
    }

    /*
     * 根据层级数返回\t的个数
     */
    private static String getTab(int level){
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<level;i++){
            sb.append("\t");
        }
        return sb.toString();
    }
}