Java-33 File类，递归，过滤思想，Lambda表达式

• File类概述：
• 文件和目录（文件夹）路径名的抽象表示形式
• java把电脑中的文件和文件夹封装成一个File类，我们可以对文件和文件夹进行操作
• File是一个与系统无关的类，任何操作系统都可以使用这个方法
• file：文件   directory：文件夹/目录   path：路径

• File的静态方法

/*
file类的静态方法
 */
public class FileDemo1 {
    public static void main(String[] args) {
        //static String pathSeparator
        //与系统相关的路径分隔符字符，为方便起见，表示为字符串。
        //static char pathSeparatorChar
        //与系统相关的路径分隔符。

        String pathSeparator = File.pathSeparator;
        System.out.println(pathSeparator);//：  注：路径分隔符  windows：分号 Linux：冒号

        //static String separator
        //与系统相关的默认名称 - 分隔符字符，以方便的方式表示为字符串。
        //static char separatorChar
        //与系统相关的默认名称分隔符。
        System.out.println(File.separator);// \ 注：文件名分割符 windows：\  linux：/

    }
}

 

•  File的构造方法
  • public File(String pathname)
  • public File(String parent,String child)
  • public File(File parent,String child)

import java.io.File;

/*
  File类的构造方法：
            public File(String pathname)
            public File(String parent,String child)
            public File(File parent,String child)
 */
public class FileDemo2 {
    public static void main(String[] args) {
        // public File(String pathname)
        //相对路径，绝对路径，文件夹和文件都可以，不考虑路径真假情况
        File file1 = new File("D:\\soft\\ideaProject\\src\\com\\shujia\\day1\\day22");//绝对路径
        File file = new File("a.txt");//相对路径
        System.out.println(file1);//D:\soft\ideaProject\src\com\shujia\day1\day22
        System.out.println(file);//a.txt

        // public File(String parent,String child)
        //根据一个目录和一个子文件（目录）得到一个File对象
        //父路径和子路径，可以单独书写，使用灵活，都可以变化
        System.out.println(new File("D:\\soft", "a.txt"));
        //D:\soft\a.txt
        System.out.println(new File("D:\\soft", "ideaProject"));
        //D:\soft\ideaProject

        //public File(File parent,String child)
        //根据一个父的File对象和一个子文件（目录）得到一个File对象
        //父路径时file类型，可以对父路径进行一些操作，再使用路径创建对象
        File file2 = new File(file1, "a.txt");
        System.out.println(file2);
        //D:\soft\ideaProject\src\com\shujia\day1\day22\a.txt
    }
}

 

• File类的成员方法：
  • 创建功能
    •  public boolean createNewFile()
    • public boolean mkdir()
    • public boolean mkdirs()
  • 删除功能
    •  public boolean delete()
  • 重命名功能
    •  public boolean renameTo(File dest)

import java.io.File;
import java.io.IOException;

/*
创建功能
            public boolean createNewFile()  创建文件
            public boolean mkdir()  创建文件夹
            public boolean mkdirs() 创建多级文件夹
 */
public class FileDemo3 {
    public static void main(String[] args) throws IOException {
        //public boolean createNewFile()
        //创建一个新的文件
        //如果该文件已经存在，就不会创建，不会报错
        //想要在指定目录下创建文件，前提是该目录必须存在，否在报错
        File file = new File("D:\\soft\\aa.txt");
        System.out.println(file.createNewFile());//true

        //public boolean mkdir()
        //在指定目录下创建文件夹
        //如果已经存在了这样的文件夹，就不会创建了，返回false
        File file1 = new File("D:\\soft\\aa");
        System.out.println(file1.mkdir());//true

        //public boolean mkdirs()
        //创建多级文件夹
        File file2 = new File("D:\\soft\\aa\\a\\aaaa");
        System.out.println(file2.mkdirs());//true
        System.out.println(file.mkdir());//true
        //win11中文件和文件夹的名字不能重复
    }
}

import java.io.File;
import java.io.IOException;

/*
 删除功能
            public boolean delete()
 */
public class FileDemo4 {
    public static void main(String[] args) throws IOException {
        //在当前项目的根目录文件夹下创建一个文件
        //相对路径
        File file = new File("D:\\soft\\ideaProject\\src\\com\\shujia\\day1\\day22\\a.txt");
        File file1 = new File("shujia\\day1\\day22\\b.txt");
        file.createNewFile();
        file.delete();
        file1.createNewFile();
        file1.delete();

        //在当前项目的根目录文件夹下创建多级目录
        File file2 = new File("demo1\\demo2\\demo3");
        file2.mkdirs();
        file2.delete();
        //想要删除一个文件夹,该文件夹里面的内容必须是空的
        //删除demo1这个文件夹
        File demo1 = new File("demo1");
        demo1.delete();

        //删除demo2文件夹
        File file3 = new File("demo1\\demo2");
        file3.delete();
        //再删除demo1文件夹
        demo1.delete();
    }
}

import java.io.File;
import java.io.IOException;

/*
重命名功能：
            public boolean renameTo(File dest)
 */
public class FileDemo9 {
    public static void main(String[] args) throws IOException {
        File file = new File("shujia\\day1\\day22\\a.txt");
        file.createNewFile();

        File file1 = new File("shujia\\day1\\day22\\b.txt");
        file.renameTo(file1);
    }
}

 

 成员方法的判断功能：

　　public boolean isDirectory()

　　public boolean isFile()

　　public boolean exists()

　　public boolean canRead()

　　public boolean canWrite()

　　public boolean isHidden()

import java.io.File;

/*
 判断功能
                public boolean isDirectory()
                public boolean isFile()
                public boolean exists()
                public boolean canRead()
                public boolean canWrite()
                public boolean isHidden()
 */
public class FileDemo6 {
    public static void main(String[] args) {
        //创建一个File对象
        File file = new File("shujia\\day1\\day22\\c.txt");

        //public boolean isDirectory()
        //判断是否是文件夹
        System.out.println(file.isDirectory());//false

        //public boolean isFile()
        //判断是否是文件
        System.out.println(file.isFile());//true

        //public boolean exists()
        //判断文件是否存在
        System.out.println(file.exists());//true

        //public boolean canRead()
        //判断是否可读
        System.out.println(file.canRead());//true

        //public boolean canWrite()
        //判断是否可写
        System.out.println(file.canWrite());//true

        //public boolean isHidden()
        //判断是否隐藏
        System.out.println(file.isHidden());//false
    }
}

 

获取功能：

 　　　　　　　　　　　public String getAbsolutePath()//获取绝对路径，换句话说，就是完整路径
                    public String getPath()//获取相对路径
                    public String getName()//获取名称
                    public long length()//获取文件的字节大小
                    public long lastModified() //最后一次被修改的时间戳，精确到了毫秒

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
  基本获取功能
                    public String getAbsolutePath()//获取绝对路径，换句话说，就是完整路径
                    public String getPath()//获取相对路径
                    public String getName()//获取名称
                    public long length()//获取文件的字节大小
                    public long lastModified() //最后一次被修改的时间戳，精确到了毫秒
 */
public class FileDemo7 {
    public static void main(String[] args) {
        //创建一个File对象
        File file = new File("shujia\\day1\\day22\\c.txt");

        //public String getAbsolutePath()
        //获取绝对路径，换句话说，就是完整路径
        System.out.println(file.getAbsolutePath());//D:\soft\ideaProject\src\com\shujia\day1\day22\c.txt

        //public String getPath()
        //获取相对路径
        System.out.println(file.getPath());//shujia\day1\day22\c.txt

        //public String getName()
        //获取名称
        System.out.println(file.getName());//c.txt

        //public long length()
        //获取文件的字节大小
        System.out.println(file.length());//0

        //public long lastModified()
        //最后一次被修改的时间戳，精确到了毫秒
        //1634308976786
        System.out.println(file.lastModified());//1634817574137

        //1634607859054
        //时间戳与日期之间的转换
        Date date = new Date(1634817574137L);

        //HH代表24小时。hh代表12小时
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        String format = sdf.format(date);
        System.out.println(format);//2021-10-21 19:59:34
    }
}

 

高级获取功能（File类遍历目录（文件夹）功能）：

　　public String[] list()

　　public File[] listFiles()

/*
高级获取功能
                    public String[] list()
                    //获取指定目录下的所有文件或者文件夹的名称，组成一个数组
                    public File[] listFiles()
                    //获取指定目录下的所有文件或者文件夹的File数组
 */
public class FileDemo8 {
    public static void main(String[] args) {
        File file = new File("D:\\code");

        String[] list = file.list();
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("-----------------");

        File[] files = file.listFiles();
        for (File file1 : files) {
            System.out.println(file1.getName());
        }
    }
}

获取文件长度：

public  long  length()

返回的是构造方法指定的文件的大小，以字节为单位

注意： 

　　文件是没有大小概念的，不能获取文件的大小

　　如果构造方法中给出的文件不存在，那么length方式返回0

import java.io.File;
import java.io.IOException;

/*
long length()
返回由此抽象路径名表示的文件的长度。
 */
public class FileDemo9 {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\图片\\研磨.png");
        System.out.println(file.length());//1968564
        File file1 = new File("D:\\图片\\大王.png");
        System.out.println(file1.length());//0 表示不存在
    }
}

一个关于文件封装遍历查找的例题：

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

/*
判断D:\\user\\download目录下是否有后缀名为.jpg的文件，如果有，就输出此文件名称
            1、把D:\\user\\download封装成一个File对象
            2、获取该目录下所有的文件和文件夹的File数组
            3、遍历该数组，得到每一个File对象，然后判断是否是文件
            4、判断是否是文件
                是：继续判断是否名称以.jpg后缀的
                    是：输出该文件的名称
                    不是：跳过

*/


public class FileTxt {
    public static void main(String[] args) {
        //1、把D:\\user\\download封装成一个File对象
        File file = new File("D:\\user\\download");

        //获取该目录下所有的文件和文件夹的File数组
        File[] files = file.listFiles();

        //新建集合
        ArrayList<String> s = new ArrayList<>();

        //遍历该数组，得到每一个File对象，然后判断是否是文件
        for (File file1 : files) {
            //判断是否是文件
            if (file1.isFile()) {
                if (file1.getName().endsWith(".jpg")) {
                    s.add(file1.getName());
                }
            }
        }

        //集合遍历
        for (String s1 : s) {
            System.out.println(s1);
        }

    }
}

递归：

 

 

 递归求阶乘：

/*
 递归求阶乘：
            5！= 5*4*3*2*1 = 120
               = 5 * 4！
               = 5 * 4 * 3！
               = 5 * 4 * 3 * 2！
               = 5 * 4 * 3 * 2 * 1！
 */
public class RecourseDemo {
    public static void main(String[] args) {
        System.out.println(fun(5));
        System.out.println(fun1(1, 5));
    }

    //自上而下
    public static int fun(int i) {
        if (i == 1) {
            return 1;

        } else {
            return i * fun(i - 1);
        }
    }

    //自下而上
    public static int fun1(int i, int i1) {
        if (i == i1) {
            return i;
        } else {
            return i * fun1(i + 1, i1);
        }
    }
    
}

 

斐波拉契数列（兔子问题）

/*
        斐波拉契数列：（兔子问题）
            有一对兔子，从出生的第三个月起，每个月都生一对兔子，小兔子长到第三个月后每个月又生
            一对兔子，假设这些兔子都不死，问：20个月的兔子，有多少对？
            找规律：
               月         兔子对数
               第一个月      1
               第二个月      1
               第三个月      2
               第四个月      3
               第五个月      5
               第六个月      8
               ...
               由此可见，兔子的对数的数据是：
               1，1，2，3，5，8，13，21...
           发现的规律是：
                1、从第三项开始，每一项都是前两项的和
                2、说明每一项的前两项的数据是已知
           如何实现呢？
                1、数组方式实现
                2、基本变量实现
                3、递归方式实现
 */
public class RecorsionDemo2 {
    public static void main(String[] args) {
        //数组实现
        //定义数组
        int[] arr = new int[20];
        arr[0] = 1;
        arr[1] = 1;
        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }

        System.out.println("第20个月的兔子对数为：" + arr[19]); //6765
        System.out.println("------------------------");

        //基本变量实现
        int a = 1;
        int b = 1;
        int temp = 0;
        for (int i = 0; i < 18; i++) {
            temp = a;
            a = b;
            b = temp + a;
        }
        System.out.println("第20个月的兔子对数为：" + b);


        //递归实现
        System.out.println(fibonacci(20));
    }

    public static int fibonacci(int i){//5
        if (i==1 ||i==2){
            return 1;
        }else{
            //fibonacci(4) + fibonacci(3)
            //fibonacci(3) + fibonacci(2) + fibonacci(2) +fibonacci(1)
            //fibonacci(2) + fibonacci(1) + 1 + 1 + 1
            //1 + 1 + 1 + 1 + 1
            //5
            return fibonacci(i-1)+fibonacci(i-2);
        }
    }
}

 

import java.io.File;

/*
     打印多级D:\\abc目录，筛选打印所有".java"文件
 */
public class FileText2 {
    public static void main(String[] args) {
        fun(new File("D:\\abc"));
    }

    public static void fun(File files){
        File[] f = files.listFiles();
        for (File file : f) {
            if (file.isDirectory()){
                 fun(file);
            }else{
                if (file.getName().toLowerCase().endsWith(".java")) {
                    System.out.println(file);
                }
            }
        }
    }
}

 

文件名称过滤器的实现思想及代码
　　public String[] list(FilenameFilter filter)
　　public File[] listFiles(FilenameFilter filter)

 

 

 

 思想：

 

 

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

/*
File类中有两个和ListFIel重载的方法.方法的参数式过滤器
public String[] list(FilenameFilter filter)
public File[] listFiles(FilenameFilter filter)

 //File[] listFiles(FileFilter filter)
        //返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。
//File[] listFiles(FilenameFilter filter)
        //返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。
 */
public class FileFileterDemo {
    public static void main(String[] args) {
        //两种过滤器的直接递归实现
        fun(new File("D:\\abc"));
        fun1(new File("D:\\abc"));
    }

    //
    public static void fun(File file){
        //File[] listFiles(FileFilter filter)
        //返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。
        File[] files = file.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.isDirectory()){
                    fun(pathname);
                }
                return pathname.getName().toLowerCase().endsWith(".java");
            }
        });

        for (File file1 : files) {
            System.out.println(file1);
        }
    }

    public static void fun1(File files){
        //File[] listFiles(FilenameFilter filter)
        //返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。
        File[] files1 = files.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                File file = new File(dir, name);
                if (file.isDirectory()) {
                    fun1(file);
                }
                return name.toLowerCase().endsWith(".java");
            }
        });

        for (File file : files1) {
            System.out.println(file);
        }
    }
}

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

public class FileFileterDemo1 {
    public static void main(String[] args) {
        getAllFile(new File("D:\\abc"));
        getAllFile1(new File("D:\\abc"));
    }

    public static void getAllFile(File files) {
        //File[] listFiles(FileFilter filter)
        //传递过滤器对象，使用匿名内部类
        File[] files1 = files.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                //过滤规则，pathname是文件夹还是以.java结尾的文件返回true
                return pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java");
            }
        });


        for (File file : files1) {
            //对遍历得到的File对象进行判断是否文件夹
            if (file.isDirectory()) {
                //如果是直接递归
                getAllFile(file);
            } else {
                System.out.println(file);
            }
        }
    }

    public static void getAllFile1(File files) {
        File[] files1 = files.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return new File(dir, name).isDirectory() || name.toLowerCase().endsWith(".java");
            }
        });

        for (File file : files1) {
            if (file.isDirectory()) {
                getAllFile1(file);
            } else {
                System.out.println(file);
            }
        }
    }
}

 

 

Lambda表达式(JDK 1.8新特性)

lambda表达式标准格式：

　　（参数列表）->{一些重写方法的代码}

 

 

 

 

public class LambdaDemo {
    public static void main(String[] args) {
        //调用invokeCook方法，参数是接口，传递cook接口的匿名内部类
        invokeCook(new Cook() {
            @Override
            public void makefood() {
                System.out.println("做中餐");
            }
        });

        //使用lambda表达式
        invokeCook(() -> {
            System.out.println("做中餐");
        });

        //使用lambda简略模式
        invokeCook(() ->
                System.out.println("做中餐")
        );
    }

    //定义一个方法，参数传递Cook接口，方法内部调用Cook中的makefood方法
    public static void invokeCook(Cook cook) {
        cook.makefood();
    }
}

 

 

import java.util.Arrays;
import java.util.Comparator;

public class LambdaDemo2 {
    public static void main(String[] args) {
        //使用数组存储多个person对象
        Person[] people = {
                new Person("翔阳",18),
                new Person("影山",19),
                new Person("月岛萤",20),
        };

        //对数组中的person对象使用arrays的sort方法对年龄进行升序
//        Arrays.sort(people, new Comparator<Person>() {
//            @Override
//            public int compare(Person o1, Person o2) {
//                return o1.getAge()-o2.getAge();
//            }
//        });

        //使用lambda表达式简略表达
//        Arrays.sort(people, (Person o1, Person o2) ->{
//                return o1.getAge()-o2.getAge();
//            });

        //使用lambda表达式简略表达
        Arrays.sort(people,(o1,  o2)-> o1.getAge()-o2.getAge());

        //遍历数组
        for (Person person : people) {
            System.out.println(person);
        }
    }
}

 

 

过滤器案例的lambda简略写法

//File[] listFiles(FileFilter filter)
        //传递过滤器对象，使用匿名内部类
        //使用lambda表达式
        File[] files1 = files.listFiles((pathname) ->pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java"));

 //使用lambda表达式
        File[] files1 = files.listFiles((dir,name) -> new File(dir, name).isDirectory() || name.toLowerCase().endsWith(".java"));