Java Lecture 14 File类、Filefilter类、递归和Lambda表达式

一、File类

通过这个类,我们可以用程序来访问我们电脑上的磁盘文件等..进行写入或读取的操作。

File类的每一个实例可以表示硬盘中的一个文件或目录(文件夹)。

java.io.File  使用File这个类需要导入这个包

使用File类可以做到：

1.访问文件或目录的属性信息。例如名字,大小,修饰时间等等。

package filedemo;
​
import java.io.File;
​
/**
 * java.io.File  使用File这个类需要导入这个包
 * File表示是系统上一个文件或目录(实例本质就是路径)
 * 1.访问文件或目录
 * 2.创建和删除
 * 3.访问目录下所有子项
 */
public class FileDemo {
    public static void main(String[] args) {
        /**
         *  File的构造方法中,需要传递进入一个路径
         *
         * 绝对路径：在我的电脑上,我一定能访问到的路径  (开发不用)
         * 相对路径(推荐): ./(相对路径) 当前项目放在哪里,那么当前路径就表示在哪里.
         */
        File file = new File("./demo.txt");
        String fileName = file.getName();//代表获取文件名字+后缀
        System.out.println(fileName);
        long length = file.length(); //代表获取文件长度
        System.out.println(length);
        boolean cr = file.canRead();//是否可读
        boolean cw = file.canWrite();//是否可写
        System.out.println(cr);
        System.out.println(cw);
        boolean in= file.isHidden();//是否隐藏
        System.out.println(in);
        //---------------------------------
        System.out.println("是否是文件: "+file.isFile());
        System.out.println("该文件或目录是否存在" + file.exists());
        System.out.println("获取父级路径："+file.getParent());
        System.out.println("获取当前文件路径："+file.getPath());
        System.out.println("获取文件完整路径："+file.getAbsolutePath());
​
    }
​
}

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

创建文件：file.createNewFile()

创建文件夹：dir.mkdir()

注意，在创建之前，都需要实例化file和dir，并且，实例化dir和实例化file的语法是一致的。

也可以选择实例化多个文件夹，比如File dir = new File("./test/a/b/c/d/e");那在创建文件夹时语法要改为，dir. mkdirs()

package filedemo;
​
import java.io.File;
​
/**
 * 删除文件或目录的使用演示类:
 */
public class DeleteFileOrDirDemo {
    public static void main(String[] args) {
         //删除文件夹  test
        File dir = new File("./test/a/b/c/d/e");
        //目录的删除 是要保证该目录是一个空的目录才可以删除
        if(dir.exists()){
            dir.delete();//删除文件夹
            System.out.println("删除成功");
        }else {
            System.out.println("目录不存在");
        }
​
​
​
//        //删除项目路径下 demo02.txt 文件
//        File file = new File("./demo02.txt");
//        if(file.exists()){ //当前文件是否存在
//            file.delete();//删除文件的方法
//            System.out.println("删除成功");
//        }else {
//            System.out.println("文件不存在");
//        }
​
    }
}
​

3.访问一个目录下所有的子项.

isDirectory（）判断是否为文件夹

listFiles返回一个数组，装的是所有子项的路径。

package filedemo;
​
import java.io.File;
​
/**
 * 获取一个文件夹(目录)下所有子项的使用演示类：
 */
public class ListFileDemo {
    public static void main(String[] args) {
        //获取项目路径下子项
        File dir = new File(".");//.代表当前项目路径的意思
        if(dir.isDirectory()){//判断当前dir路径是否是文件夹(目录)
           File[] files = dir.listFiles();//获取当前dir路径下所有子项文件
            for (int i = 0; i < files.length; i++) {//遍历files数组
                System.out.println(files[i].getName());//打印数组中每个路径对象的名字
            }
        }
    }
}
​

二、递归(recursion)

是程序中常见解决问题的手段(尽可能不用,效率低下)

递归在使用时,容易产生死循环,使用递归都会加一个可以退出的条件.

递归的思想:自己调自己(本方法内部又调用本方法),也可以间接又调用自己.

循环是重复执行某段代码, 递归则是重复整个过程.

递归的例子：

1. 递归删除文件夹：

​
import java.io.File;
​
/**
 * 递归删除文件夹的是使用演示类:
 */
public class RecursionDemo {
    public static void main(String[] args) {
​
        deleteDir(new File("./test"));
    }
​
    public static void deleteDir(File file) {
        /**
         *  先判断 传入的file文件路径对象 是否是文件夹
         *  若是 获取该文件夹所有子项 ---File[]
         *  循环遍历File[] 再判断每个子项有没有是文件夹的
         *  若是 获取该文件夹所有子项 ---File[]
         *  ...若是循环过程 是否可以直接调用当前方法 传入路径
         *  若不是 则执行delete
         */
        if (file.isDirectory()) {//判断当前传入的内容是否是文件夹
            File[] files = file.listFiles();//获取所有子项
            for (int i = 0; i < files.length; i++) {
                deleteDir(files[i]);//递归：调用本方法继续往下套
            }
        }
        file.delete();
    }
    //练习需求：获取指定的目录下，输出所有的目录 和 文件的 名字。
​
}
​
​

2. 获取指定目录下的所有文件和文件夹的名字

  public static void main(String[] args) {
​
      //  deleteDir(new File("./test"));
        diGuiPrint(new File("./test"));
    }
    //练习需求：获取指定的目录下，输出所有的目录 和 文件的 名字。
    public static  void diGuiPrint(File file){
        /**
         *  1.判断file 是否是文件  如果是 则return即可.
         *  2.如果是目录
         *      获取当前目录下所有子项  ---File[]
         *      遍历File[]  如果遍历到的是文件 直接输出文件名
         *                 如果遍历到的是目录 打印名字 并需要递归继续往下套.
         */
        if(file.isFile()){//如果是文件
            return;  //退出当前方法
        }
        File[] files = file.listFiles();//获取目录下所有子项
        for (int i = 0; i < files.length; i++) {
            if(files[i].isFile()){//如果当前子项对象是文件
                System.out.println(files[i].getName());//打印文件的名字
            }else {//否则是文件夹
                System.out.println(files[i].getName());//打印目录的名字
                diGuiPrint(files[i]);//递归:向下套
            }
        }
    }

3. 面试题: 请写一个方法,传入100这个数据,该方法则会返回1+2+3+4+5+6+...+100的和
注意:不能使用循环

    //斐波那契数列  公式   ---- 递归
    public static int recursionTest(int number) {
        if (number >= 1) {
            //规律:  100 + 99 + 98 + 97 + 96 + ....+ 1
            number += recursionTest(number-1);
        }
        return number;
    }

4. 可以有条件的筛选文件夹子项（文件过滤器）:

这个例子的需求是拿到这个路径下 文件名包含o 的字母文件 或 目录

这里引入了FileFilter类，用了匿名内部类对它的accept方法进行重写。筛选完的filter要放在file.listFiles的括号里，这样才能输出条件下的file数组。

package filedemo;
​
import java.io.File;
import java.io.FileFilter;
import java.util.Arrays;
​
/**
 * 文件过滤器的使用演示类:
 */
public class ListFileDemo02 {
​
    public static void main(String[] args) {
        File file = new File(".");//当项目路径
        if (file.isDirectory()) {//判断是否是文件夹
            FileFilter filter = new FileFilter() {
                @Override                  //file 代表就是获取到的每个子项路径
                public boolean accept(File file) {
                    return file.getName().startsWith(".");//需求：过滤条件,  文件名中以.开头文件或目录的保留
                   return file.getName().contains("o"); //过滤条件 文件或目录中包含有o字母的名字保留
                }  //需求：过滤条件,  文件名中以.开头文件或目录的保留
            };
            //需求：拿到这个路径下 文件名包含o 的字母文件 或 目录
            File[] files = file.listFiles(filter);
            System.out.println(Arrays.toString(files));
        }
    }
}

三、Lambda表达式

JDK8以后推出的一个新特性

作用：可以让Java面向函数式编程,以更精简的语法,实现匿名内部类的语法。

语法： (参数) -> { 方法体 }

注意:使用lambda表达式来创建匿名内部类时,要确保重写的那个父类/接口抽象方法只有

一个.

有三种写法，具体看下面的代码：

        //使用lambda 形式一:
        File file = new File(".");//当项目路径
        FileFilter filter = (File fileName) ->{
            return fileName.getName().contains("o");
      };
​
        //使用lambda 形式二 : 方法参数只有一个 方法参数类型可以不用写,小括号也可以不用写
        FileFilter filter1 = fileName ->{
            return fileName.getName().contains("o");
        };
        //使用lambda 形式三 : 如果方法体中 只有一行代码, 花括号不用写 return 不用写
        FileFilter filter = fileName -> fileName.getName().contains("o");
        
​
        File[] files = file.listFiles(filter);
        System.out.println(Arrays.toString(files));