让我们了解Java-IO-File类，随心所欲操控文件(夹)^~^

最新推荐文章于 2024-08-04 11:07:52 发布

owerm

最新推荐文章于 2024-08-04 11:07:52 发布

阅读量1.5k

点赞数 43

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/owerm/article/details/135174435

版权

欢迎Java初学者的朋友们来到我的代码世界，让我们了解Java-IO-File类，随心所欲操控文件及文件夹，*^~^*

（温馨提示：我在file使用的12、renameTo，用了创建新文件及新文件夹请注释之后的代码，在运行程序3次后继续看下面代码，否则可能会出现错误）

/*
*
* I/O(输入/输出)
* 输入/输出流 、file类(文件的创建于删除、读取文件信息)、文件输入/输出流、(主要)带缓存的输入/输出流、数据输入/输出流
* InputStream字节流输入流\Reader字符流输入流 、OutputStream字节流输出流  都是抽象类
* InputStream字节流输入流 处理Unicode编码(双字节)
*
*
*
* */

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

public class Io_stu {
    public static void main(String[] args) {
        System.out.println("欢迎Java初学者的朋友们来到我的代码世界，让我们了解Java-IO-File类," +
                "随心所欲操控文件及文件夹，*^~^* ");
        System.out.println("\n（温馨提示：我在file使用的12、renameTo，用了创建新文件及新文件夹 请注释之后的代码，在运行程序3次后 " +
                "继续看下面代码，否则可能会出现错误）\n");
        //一.创建文件对象File
        System.out.println("一、File类创建:");
        System.out.println("总共3种构造方法创建文件或文件夹对象:");

        //1、File(String pathname)

        //  代码中的\\，第一个\是转义符，第二个\是表示一个\.
        // 仅仅创建文件路径 ，这种路径写法称为绝对路径：D:\笔记记录\io\File\testfile.txt
        File file = new File("D:\\笔记记录\\io\\File\\testfile.txt");
        //也可以这样写
        File file_1_1 = new File("D:/笔记记录/io/File/testfile.txt");
        System.out.println("File(String pathname) 创建抽象实例对象，实例对象名字："+file.getName());
        System.out.println("File(String pathname) 创建抽象实例对象，实例对象名字："+file_1_1.getName());
        System.out.println("----------------------");

        //2、File(String parent,String child)
        File file_2 = new File("D:\\笔记记录\\io\\File","testfile.txt");
        //也可以这样写
        File file_2_1 = new File("D:/笔记记录/io/File/","testfile.txt");
        System.out.println("File(String parent,String child) 创建抽象实例对象，实例对象名字："+file_2.getName());
        System.out.println("File(String parent,String child) 创建抽象实例对象，实例对象名字："+file_2_1.getName());
        System.out.println("----------------------");

        //3、File(File parent,String child)
        File file_3 = new File(new File("D:\\笔记记录\\io\\File"),"testfile.txt");
        System.out.println("File(String parent,String child) 创建抽象实例对象，实例对象名字："+file_3.getName());
        //也可以这样写
        File filedir = new File("D:\\笔记记录\\io\\File");
        File file_3_1 = new File(filedir,"testfile.txt");
        System.out.println("File(String parent,String child) 创建抽象实例对象，实例对象名字："+file_3_1.getName());
        System.out.println("----------------------");


        System.out.println();
        System.out.println("=======================");
        System.out.println("3种构造方法创建方法实现路径一样，用getAbsoluteFile获取绝对路径：");
        System.out.println("File(String pathname) 绝对路径："+file.getAbsoluteFile());
        System.out.println("File(String parent,String child)) 绝对路径："+file_2.getAbsoluteFile());
        System.out.println("File(File(File parent,String child)) 绝对路径："+file_3.getAbsoluteFile());


        System.out.println();
        System.out.println("=======================");
        System.out.println("3种构造方法创建方法，抽象实例对象不相等，用==对比,结果：");
        //不加括号也可以，主要为了读者清楚
        System.out.println("file == file_2 结果"+(file == file_2));
        System.out.println("file == file_3 结果"+(file == file_3));
        System.out.println("file_3 == file_2 结果"+(file_3 == file_2));
        System.out.println("因为它们都是独立对象,所以结果为false");


        System.out.println();
        System.out.println("=======================");
        System.out.println("3种构造方法创建方法，虽然抽象实例对象都是独立，但指向同一个文件或文件夹(不管它存不存在)，用equals,结果：");
        System.out.println("file.equals(file_2) 结果"+file.equals(file_2));
        System.out.println("file.equals(file_3) 结果"+file.equals(file_3));
        System.out.println("file_3.equals(file_2) 结果"+file_3.equals(file_2));


        //举例了一个文件夹的抽象实例对象
        System.out.println();
        System.out.println("=======================");
        System.out.println("上面3构造方法都可以，在讲第3种构造方法时也举例了文件对象创建，在这里在简单举例一个文件夹对象例子:");
        File folder = new File("D:\\笔记记录\\io\\File\\testfolder");
        System.out.println("它只是一个文件对象，文件名称："+folder.getName());



        System.out.println("\n\n++++++++++++++++++++++++++++++++++");
        System.out.println("二、File的使用");
        System.out.println("\n(提示：1、文件和文件夹我都在硬盘上真实创建好了，文件加入了数据和文件夹也加入了有数据的文件。\n" +
                "2、如果硬盘没有，请创建，因大部分代码是建立与文件或文件夹真实存在情况。" +
                "3、建议习惯用try捕捉错误)");
        System.out.println("\n1、判断文件或文件夹是否存在，用exists 结果：\n");
        System.out.println("文件是否存在，结果："+file.exists());
        System.out.println("文件夹是否存在，结果："+folder.exists());


        System.out.println();
        System.out.println("=======================");
        System.out.println("2、判断文件或文件夹是否是文件夹，用isDirectory 结果：\n");
        System.out.println("文件是否为文件夹，结果："+file.isDirectory());
        System.out.println("文件夹是否为文件夹，结果："+folder.isDirectory());


        System.out.println("\n=======================");
        System.out.println("3、获取文件或文件夹名称 用getName 结果：\n");
        System.out.println("文件名称："+file.getName());
        System.out.println("文件夹名称："+folder.getName());


        System.out.println("\n=======================");
        System.out.println("4、获取文件或文件夹的绝对路径。 用getAbsolutePath 结果：\n");
        System.out.println("文件绝对路径："+file.getAbsolutePath());
        System.out.println("文件夹绝对路径："+folder.getAbsolutePath());


        System.out.println("\n=======================");
        System.out.println("5、文件或文件夹是否设置隐藏文件，如果false 为没有隐藏，反之隐藏。 用isHidden 结果：\n");
        System.out.println("判断，文件是否为隐藏文件："+file.isHidden());
        System.out.println("判断，文件夹是否为隐藏文件："+folder.isHidden());


        System.out.println();
        System.out.println("\n=======================");
        System.out.println("6、查看文件大小（即文件内容），用length(注意：文件夹的大小无法查看。虽然系统不会报错，但结果显示为0.) 结果：\n");
        System.out.println("文件大小用字节数表示，字节数为："+file.length());
        System.out.println("文件夹大小用字节数表示，字节数为："+folder.length());
        System.out.println("\n从上面例子就可以表明File类的方法及属性都比较适合文件对象操作，而不适合文件夹对象操作");


        System.out.println("\n=======================");
        System.out.println("7、获取文件或文件夹的父文件夹，用getParent 结果：");
        System.out.println("文件父文件夹："+file.getParent());
        System.out.println("文件夹父文件夹："+folder.getParent());


        System.out.println("\n=======================");
        System.out.println("8、获取文件或文件夹的父文件夹的抽象实例对象，用getParentFile 会显示父文件夹的实例对象(为File类对象)的路径， 结果：\n");
        System.out.println("文件父文件夹："+file.getParentFile());
        System.out.println("文件夹父文件夹："+folder.getParentFile());
        System.out.println("举例：\n父文件夹对象获取父文件夹名称");
        File parentFile = file.getParentFile();
        System.out.println("父文件夹名称："+parentFile.getName());


        System.out.println("\n=======================");
        System.out.println("9,获取文件及文件夹最后的修改时间，用lastModified（注意：返回的数据的类型为Long,值是：毫秒值），需要进行时间格式转化。\n");
        System.out.println("获取文件最后修改时间的毫秒值 值为：" + file.lastModified());
        System.out.println("把毫秒值转换为时间格式 结果：");
        Date date = new Date(file.lastModified());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(sdf.format(date));
        System.out.println("----------------------");
        System.out.println("获取文件夹最后修改时间的毫秒值 值为：" + folder.lastModified());
        System.out.println("把毫秒值转换为时间格式 结果：");
        date = new Date(folder.lastModified());
        System.out.println(sdf.format(date));
        System.out.println("\n注意：右键单击文件夹属性是看不到的文件夹最后修改时间，可以自己通过文件夹放入文件或删除文件并记录当前时间，在运行代码，就可以了解代码是否正确");


        System.out.println("\n=======================");
        System.out.println("10、创建文件或文件夹 用createNewFile 创建文件 返回值为Boolean类型\n(注意如果文件本身存在硬盘中，他不会去创建，再次使用这个代码，也不会报错，但有些解释器强调用try一起使用，我用的是IJ) " +
                "\n用mkdir 返回值为Boolean类型 创建文件 \n(注意如果文件本身存在硬盘中，它不会创建，再次使用这个代码，也不会报错。)  结果：\n");
        File file_add = new File("D:/笔记记录/io/File","addfile.txt");
        File folder_add = new File("D:/笔记记录/io/File","addfolder");
        try {
                file_add.createNewFile();
                System.out.println("文件创建成功,文件名为："+file_add.getName());

                folder_add.mkdir();
                System.out.println("文件夹创建成功,文件夹名为："+folder_add.getName());
        }catch (Exception e){    };


        System.out.println("\n=======================");
        System.out.println("11、删除文件或文件夹 用delete 删除文件或文件夹 返回值为Boolean类型 \n(注意如果文件本身不存在或已删除，再次使用这个代码，它不会报错) " +
                " 结果：\n");

        file_add.delete();
        System.out.println("文件删除成功,文件名为："+file_add.getName());

        folder_add.delete();
        System.out.println("文件夹删除成功,文件夹名为："+folder_add.getName());
        System.out.println("\n注意：查看创建或删除效果代码，请手动注释创建代码或删除代码。");


        System.out.println("\n=======================");
        System.out.println("12、重命名文件或文件夹 用renameTo(参数：新文件或文件夹抽象实例对象) 重命名文件或文件夹， 返回值为Boolean类型 \n" +
                "(注意: 1、如果文件本身不存在或已删除，再次使用这个代码，它不会报错) " +
                "之前代码删除了文件及文件夹，需要在创建文件或文件夹在运行renameTo  结果：\n");

        try {
            file_add.createNewFile();
            System.out.println("文件创建成功,文件名为："+file_add.getName());

            folder_add.mkdir();
            System.out.println("文件夹创建成功,文件夹名为："+folder_add.getName());
        }catch (Exception e){    };

        System.out.println("----------------------");

        File file_add_rename = new File("D:/笔记记录/io/File","addfile_rename.txt");
        file_add.renameTo(file_add_rename);
        System.out.println("文件重命名成功,文件名为："+file_add_rename.getName());

        File folder_add_rename = new File("D:/笔记记录/io/File","addfolder_rename");
        folder_add.renameTo(folder_add_rename);
        System.out.println("文件夹重命名成功,文件夹名为："+folder_add_rename.getName());

        System.out.println("\n注意：folder_add或file_add抽象类实例是根据虚拟路径创建，如果原来文件已重新命名后，不会指向重新命名后文件，" +
                "\n需用createNewFile或mkdir会在硬盘上创建出folder_add的文件或file_add的文件夹，否则运用其他代码出错");

        System.out.println("\n=======================");
        System.out.println("13、canExecute() 方法返回一个布尔值，表示应用程序是否可以对文件进行“执行”操作。" +
                "如果可以，它返回 true，否则返回 false。\n");
        System.out.println("注意：1、canExecute() 的结果可能受到多种因素的影响，包括操作系统的文件权限设置、Java虚拟机的安全策略等。" +
                "\n因此，即使 canExecute() 返回 true，也不能保证你的应用程序就一定能成功执行该文件。" +
                "在实际尝试执行文件之前，最好做好错误处理准备。\n" +
                "\t 2、如若返回不执行结果，可能硬盘上文件或文件夹已删除或不存在\n");

        System.out.println(file_add.getName()+"文件是否可以执行 结果: " + file_add.canExecute());
        System.out.println(folder_add.getName()+"文件是否可以执行 结果: " + folder_add_rename.canExecute());


        System.out.println("\n=======================");
        System.out.println("14、canRead() 方法返回一个布尔值，表示应用程序是否可以读取文件。" +
                "如果可以，它返回 true，否则返回 false。\n");
        System.out.println("注意：1、canRead() 的结果可能受到多种因素的影响，包括操作系统的文件权限设置、Java虚拟机的安全策略等。" +
                "\n因此，即使 canRead() 返回 true，也不能保证你的应用程序就一定能成功读取该文件。" +
                "在实际尝试读取文件之前，最好做好错误处理准备。\n" +
                "\t 2、如若返回不读取结果，可能硬盘上文件或文件夹已删除或不存在.\n");
        System.out.println(file_add.getName()+"文件是否可以读取 结果: " + file_add.canRead());
        System.out.println(folder_add.getName()+"文件是否可以读取 结果: " + folder_add.canRead());


        System.out.println("\n=======================");
        System.out.println("15、canWrite() 方法返回一个布尔值，表示应用程序是否可以写入文件。" +
                "如果可以，它返回 true，否则返回 false。\n");
        System.out.println("注意：1、canWrite() 的结果可能受到多种因素的影响，包括操作系统的文件权限设置、Java虚拟机的安全策略等。" +
                "\n因此，即使 canWrite() 返回 true，也不能保证你的应用程序就一定能成功写入该文件。" +
                "在实际尝试写入文件之前，最好做好错误处理准备。\n" +
                "\t 2、如若返回不写入结果，可能硬盘上文件或文件夹已删除或不存在\n");
        System.out.println(file_add.getName()+"文件是否可以写入 结果: " + file_add.canWrite());
        System.out.println(folder_add.getName()+"文件是否可以写入 结果: " + folder_add.canWrite());


        System.out.println("\n=======================");
        System.out.println("16、compareTo(File pathname) 方法按字典顺序比较 2个抽象类实例 的路径的字符串表示形式。" +
                "\n(所谓的“字典顺序”，就是基于字符串中各个字符的Unicode值来比较字符串的顺序。)" +
                "\n该方法返回一个整数，其值可能是以下三种情况：" +
                "\n\t 1、如果当前文件路径（即调用 compareTo() 方法的 File 对象所表示的路径）" +
                "在字典顺序上位于指定文件路径之前，则返回负整数。" +
                "\n\t 2、如果两个文件路径相等，则返回零。" +
                "\n\t 3、如果当前文件路径在字典顺序上位于指定文件路径之后，则返回正整数。" +
                "\n\t结果：");
        if(file_add.compareTo(file_add_rename) < 0){
            System.out.println(file_add.getName()+"在字典顺序上位于"+file_add_rename.getName()+"之前");
        }else if(file_add.compareTo(file_add_rename) == 0){
            System.out.println(file_add.getName()+"与"+file_add_rename.getName()+"相等");
        }else {
            System.out.println(file_add.getName()+"在字典顺序上位于"+file_add_rename.getName()+"之后");
        }

        System.out.println("\n提示：这个方法，通常用于判断创建的2个抽象实例对象的路径是否一样，即指向对象是同一个对象。");


        System.out.println("\n=======================");
        System.out.println("17、deleteOnExit 当程序正常退出、通过调用 System.exit() 方法，或者虚拟机由于其他原因被终止时，" +
                "\ndeleteOnExit() 方法会尝试删除与该 File 对象关联的文件或文件夹。");

        File f_1 = new File("D:\\笔记记录\\io\\File\\addfolder\\testfile_1.txt");
        try {f_1.createNewFile();}catch (Exception e){}; //创建文件
        File fo_1 = new File("D:\\笔记记录\\io\\File\\addfolder\\testfolder_1");
        fo_1.mkdir(); //创建文件夹
        f_1.deleteOnExit();
        System.out.println(f_1.getName() + "文件在硬盘上删除");
        fo_1.deleteOnExit();
        System.out.println(fo_1.getName() + "文件夹在硬盘上删除");

        System.out.println("\n注意：1、如果文件或文件夹已删除，在运行这个代码，系统不会报错。" +
                "\n\t 2、deleteOnExit() 方法仅提供一个“最佳努力”的删除保证。这意味着当虚拟机终止时，它会尝试删除文件，" +
                "\n但如果出于某种原因（例如文件正在被另一个进程使用）文件无法被删除，那么该文件将保持原样。" +
                "\n此外，依赖于 deleteOnExit() 的代码可能会导致资源泄漏或其他问题，特别是在长时间运行的应用程序或服务器环境中。" +
                "\n因此，在使用此方法时应格外小心。\n");

        System.out.println("\n=======================");
        System.out.println("18、String[] list() 方法返回一个字符串数组，其中包含当前目录中的所有文件和文件夹的名称。" +
                "\n如果当前目录为空，则返回一个空字符串数组。" +
                "\n如果当前目录不存在，则抛出 FileNotFoundException。\n结果：");
        File folder_add_1 = new File("D:\\笔记记录\\io\\File\\addfolder_1");
        folder_add_1.mkdir();
        String[] str = folder_add_1.list();


        if(str.length == 0){
            System.out.println("当前文件为空");
        }else{
            System.out.println("当前目录中的文件和文件夹名称: ");
            for (int i = 0; i < str.length; i++) {
                System.out.println(str[i]);
            }
        }
        System.out.println("----------------------");
        //错误的显示，因为所以显示文件或文件夹名称不存在硬盘
        System.out.println("下面举例错误的显示，因为所以显示文件或文件夹名称不存在硬盘");
        String[] str_1 = folder_add.list();
        if(str_1.length == 0){
            System.out.println("当前文件为空");
        }else{
            System.out.println("当前目录中的文件和文件夹名称: ");
            for (int i = 0; i < str_1.length; i++) {
                System.out.println(str_1[i]);
            }
        }

        System.out.println("\n注意：1、list()方法 只适用于文件夹对象。" +
                "\n\t 2、返回目录（文件夹）里的所有的文件名称和文件夹名称的名称字符串集合(包含隐藏文件或文件夹的名称)(String[])的对象。" +
                "\n\t 3、如果文件夹里没有文件或文件夹，则返回空NULL." +
                "\n\t 3、如果用同一类文件执行在这个文件夹里创建文件或文件夹后删除，否则返回之前删除的文件或文件夹名称");


        System.out.println("\n=======================");
        System.out.println("19、File[] listFiles() 方法返回一个 File实例对象的数组，其中包含当前目录中的所有文件实例对象和文件夹实例对象。" +
                "\n如果当前目录为空，则返回一个空数组。" +
                "\n如果当前目录不存在，则抛出 FileNotFoundException。\n结果：");

        File[] folder_add_array = folder_add_1.listFiles();
        if(folder_add_array.length == 0){
            System.out.println(folder_add_1.getName()+"当前目录为空");
        }else{
            System.out.println(folder_add_1.getName()+"当前目录中的文件和文件夹名称: ");
            for (int i = 0; i < folder_add_array.length; i++) {
                System.out.println(folder_add_array[i].getName());
            }
        }


        System.out.println("\n=======================");
        System.out.println("20、String[] list(FilenameFilter filter) 指定筛选条件，返回名称集合的字符串集合(String[]) 结果：\n ");
        //设定筛选器条件，只显示txt结尾的文件
        FilenameFilter filter = new FilenameFilter(){
            public boolean accept(File dir, String name){
                return name.endsWith(".txt");
            }
        } ;
        String[] str_filetrs = folder_add_1.list(filter);
        if(str_filetrs.length == 0){
            System.out.println(folder_add_1.getName()+"当前目录为空或没有指定的文件名称或文件夹名称");
        }else{
            System.out.println(folder_add_1.getName()+"当前目录中指定条件为后缀为'.txt'文件名称的集合: ");
            for (int i = 0; i < str_filetrs.length; i++) {
                System.out.println(str_filetrs[i]);
            }
        }


        System.out.println("\n=======================");
        System.out.println("21、 File[] listFiles(FilenameFilter filter) 指定筛选条件，返回File实例对象的数组 结果：\n ");
        File[] folder_add_array_filters = folder_add_1.listFiles(filter);
        if(folder_add_array_filters.length == 0){
            System.out.println(folder_add_1.getName()+"当前目录为空或没有指定的文件对象或文件夹对象");
        }else{
            System.out.println(folder_add_1.getName()+"当前目录中指定条件为后缀为'.txt'文件对象集合: ");
            for (int i = 0; i < folder_add_array_filters.length; i++) {
                System.out.println(folder_add_array_filters[i].getName());
            }
        }


        System.out.println("\n=======================");
        System.out.println("21、File[] listFiles(FileFilter filter)指定筛选条件，返回File实例对象的数组 结果：\n ");
        //设定筛选器条件，只显示txt结尾的文件
        FileFilter fileFilters = new FileFilter() {
            public boolean accept(File file) {
                boolean f = file.getName().endsWith(".txt");
                System.out.println(f);
                return file.getName().endsWith(".txt");
            }
        };

        File[] folder_add_array_filters_1 = folder_add_1.listFiles(fileFilters);
        if(folder_add_array_filters_1.length == 0){
            System.out.println(folder_add_1.getName()+"当前目录为空或没有指定的文件对象或文件夹对象");
        }else{
            System.out.println(folder_add_1.getName()+"当前目录中指定条件为后缀为'.txt'文件对象集合: ");
            for (int i = 0; i < folder_add_array_filters_1.length; i++) {
                System.out.println(folder_add_array_filters_1[i].getName());
            }
        }


        System.out.println("\n=======================");
        System.out.println("22、String toPath()方法 返回抽象实例对象的路径 结果");
        System.out.println(file_add.getName()+"当前文件路径: "+file_add.toPath());
        System.out.println(folder_add.getName()+"当前文件夹路径: "+folder_add.toPath());


        System.out.println("\n=======================");
        System.out.println("23、File toURL()方法 将此抽象路径名转换为文件：URL。" +
                "\nURL的确切形式取决于系统。如果可以确定这个抽象路径名表示的文件是一个目录，" +
                "\n那么生成的URL将以斜线结束。 结果:");
        //创建抽象实例，不在硬盘上创建文件或文件夹
        File file_add_url = new File("file:/D:/笔记记录/io/File/url.txt");
        File folder_add_url = new File("file:/D:/笔记记录/io/File/url");
        try {
            System.out.println(file_add.getName()+"当前文件File实例对象: "+file_add.toURL());
            System.out.println(folder_add.getName()+"当前文件File实例对象: "+folder_add.toURL());
            System.out.println(file_add_url.getName()+"当前文件URL: "+file_add_url.toURL());
            System.out.println(folder_add_url.getName()+"当前文件URL: "+folder_add_url.toURL());
        }catch (Exception e){
            e.printStackTrace();
        };
        System.out.println("\n注意：1、toURL方法 需要与try 一起使用，" +
                "\n\t 2、仅仅是把抽象实例转化为URL" +
                "\n\t 3、此方法已开始被弃用");

        System.out.println("\n=======================");
        System.out.println("24、File getCanonicalFile()方法 返回此抽象路径名的规范化文件名，" +
                "\n即为新文件对象或新文件夹对象,需与try 一起使用  结果：\n");

        try {
            System.out.println(file_add.getName()+"当前文件转化为标准路径的新文件对象"+file_add.getCanonicalFile());
            System.out.println(folder_add.getName()+"当前文件夹转化为标准路径的新文件夹对象"+folder_add.getCanonicalFile());
        }catch (Exception e){};


        System.out.println("\n=======================");
        System.out.println("25、int hashCode()方法 返回哈希值 结果：\n");
        System.out.println(file_add.getName()+"当前文件哈希值: "+file_add.hashCode());
        System.out.println(folder_add.getName()+"当前文件夹哈希值: "+folder_add.hashCode());

        System.out.println("\n=======================");
        System.out.println("26、boolean setLastModified()  修改最后修改时间  结果：");
        //获取文件对象
        File r_file = folder_add_array[4];
        //获取修改文件后的时间，并转化为时间格式，并输出。//1703214800950L 可以用长整数表示时间参数
        //date.getTime() 把当前时间转化为长整型的毫秒数值。
        Boolean set_lastModify_boolean = r_file.setLastModified(date.getTime());
        String set_lastModify =sdf.format(r_file.lastModified());
        System.out.println(r_file.getName()+"当前文件，修改状态:"+set_lastModify_boolean+"，文件修改后的时间为："+set_lastModify);
        Boolean set_lastModify_boolean_1 = folder_add_1.setLastModified(date.getTime());
        String set_lastModify_1 =sdf.format(folder_add_1.lastModified());
        System.out.println(folder_add_1.getName()+"当前文件夹，修改状态:"+set_lastModify_boolean_1+"，文件夹修改后的时间为："+set_lastModify_1);

        System.out.println("提示： 如果想看是否修改成功，可以自己实验的文件或文件夹提前查看最后修改的时间并记下，就可以知道是否修改成功了。");


    }
}

:
总共3种构造方法创建文件或文件夹对象:
File(String pathname) 创建抽象实例对象，实例对象名字：testfile.txt
File(String pathname) 创建抽象实例对象，实例对象名字：testfile.txt
----------------------
File(String parent,String child) 创建抽象实例对象，实例对象名字：testfile.txt
File(String parent,String child) 创建抽象实例对象，实例对象名字：testfile.txt
----------------------
File(String parent,String child) 创建抽象实例对象，实例对象名字：testfile.txt
File(String parent,String child) 创建抽象实例对象，实例对象名字：testfile.txt
----------------------

=======================
3种构造方法创建方法实现路径一样，用getAbsoluteFile获取绝对路径：
File(String pathname) 绝对路径：D:\笔记记录\io\File\testfile.txt
File(String parent,String child)) 绝对路径：D:\笔记记录\io\File\testfile.txt
File(File(File parent,String child)) 绝对路径：D:\笔记记录\io\File\testfile.txt

=======================
3种构造方法创建方法，抽象实例对象不相等，用==对比,结果：
file == file_2 结果false
file == file_3 结果false
file_3 == file_2 结果false
因为它们都是独立对象,所以结果为false

=======================
3种构造方法创建方法，虽然抽象实例对象都是独立，但指向同一个文件或文件夹(不管它存不存在)，用equals,结果：
file.equals(file_2) 结果true
file.equals(file_3) 结果true
file_3.equals(file_2) 结果true

=======================
上面3构造方法都可以，在讲第3种构造方法时也举例了文件对象创建，在这里在简单举例一个文件夹对象例子:
它只是一个文件对象，文件名称：testfolder

++++++++++++++++++++++++++++++++++
二、File的使用

(提示：1、文件和文件夹我都在硬盘上真实创建好了，文件加入了数据和文件夹也加入了有数据的文件。
2、如果硬盘没有，请创建，因大部分代码是建立与文件或文件夹真实存在情况。3、建议习惯用try捕捉错误)

1、判断文件或文件夹是否存在，用exists 结果：

文件是否存在，结果：true
文件夹是否存在，结果：true

=======================
2、判断文件或文件夹是否是文件夹，用isDirectory 结果：

文件是否为文件夹，结果：false
文件夹是否为文件夹，结果：true

=======================
3、获取文件或文件夹名称用getName 结果：

文件名称：testfile.txt
文件夹名称：testfolder

=======================
4、获取文件或文件夹的绝对路径。用getAbsolutePath 结果：

文件绝对路径：D:\笔记记录\io\File\testfile.txt
文件夹绝对路径：D:\笔记记录\io\File\testfolder

=======================
5、文件或文件夹是否设置隐藏文件，如果false 为没有隐藏，反之隐藏。用isHidden 结果：

判断，文件是否为隐藏文件：false
判断，文件夹是否为隐藏文件：false

=======================
6、查看文件大小（即文件内容），用length(注意：文件夹的大小无法查看。虽然系统不会报错，但结果显示为0.) 结果：

文件大小用字节数表示，字节数为：16
文件夹大小用字节数表示，字节数为：0

从上面例子就可以表明File类的方法及属性都比较适合文件对象操作，而不适合文件夹对象操作

=======================
7、获取文件或文件夹的父文件夹，用getParent 结果：
文件父文件夹：D:\笔记记录\io\File
文件夹父文件夹：D:\笔记记录\io\File

=======================
8、获取文件或文件夹的父文件夹的抽象实例对象，用getParentFile 会显示父文件夹的实例对象(为File类对象)的路径，结果：

文件父文件夹：D:\笔记记录\io\File
文件夹父文件夹：D:\笔记记录\io\File
举例：
父文件夹对象获取父文件夹名称
父文件夹名称：File

=======================
9,获取文件及文件夹最后的修改时间，用lastModified（注意：返回的数据的类型为Long,值是：毫秒值），需要进行时间格式转化。

获取文件最后修改时间的毫秒值值为：1703132109038
把毫秒值转换为时间格式结果：
2023-12-21 12:15:09
----------------------
获取文件夹最后修改时间的毫秒值值为：1703214807950
把毫秒值转换为时间格式结果：
2023-12-22 11:13:27

注意：右键单击文件夹属性是看不到的文件夹最后修改时间，可以自己通过文件夹放入文件或删除文件并记录当前时间，在运行代码，就可以了解代码是否正确

=======================
10、创建文件或文件夹用createNewFile 创建文件返回值为Boolean类型
(注意如果文件本身存在硬盘中，他不会去创建，再次使用这个代码，也不会报错，但有些解释器强调用try一起使用，我用的是IJ)
用mkdir 返回值为Boolean类型创建文件
(注意如果文件本身存在硬盘中，它不会创建，再次使用这个代码，也不会报错。) 结果：

文件创建成功,文件名为：addfile.txt
文件夹创建成功,文件夹名为：addfolder

=======================
11、删除文件或文件夹用delete 删除文件或文件夹返回值为Boolean类型
(注意如果文件本身不存在或已删除，再次使用这个代码，它不会报错) 结果：

文件删除成功,文件名为：addfile.txt
文件夹删除成功,文件夹名为：addfolder

注意：查看创建或删除效果代码，请手动注释创建代码或删除代码。

=======================
12、重命名文件或文件夹用renameTo(参数：新文件或文件夹抽象实例对象) 重命名文件或文件夹，返回值为Boolean类型
(注意: 1、如果文件本身不存在或已删除，再次使用这个代码，它不会报错) 之前代码删除了文件及文件夹，需要在创建文件或文件夹在运行renameTo 结果：

文件创建成功,文件名为：addfile.txt
文件夹创建成功,文件夹名为：addfolder
----------------------
文件重命名成功,文件名为：addfile_rename.txt
文件夹重命名成功,文件夹名为：addfolder_rename

注意：folder_add或file_add抽象类实例是根据虚拟路径创建，如果原来文件已重新命名后，不会指向重新命名后文件，
需用createNewFile或mkdir会在硬盘上创建出folder_add的文件或file_add的文件夹，否则运用其他代码出错

=======================
13、canExecute() 方法返回一个布尔值，表示应用程序是否可以对文件进行“执行”操作。如果可以，它返回 true，否则返回 false。

注意：1、canExecute() 的结果可能受到多种因素的影响，包括操作系统的文件权限设置、Java虚拟机的安全策略等。
因此，即使 canExecute() 返回 true，也不能保证你的应用程序就一定能成功执行该文件。在实际尝试执行文件之前，最好做好错误处理准备。
2、如若返回不执行结果，可能硬盘上文件或文件夹已删除或不存在

addfile.txt文件是否可以执行结果: true
addfolder文件是否可以执行结果: true

=======================
14、canRead() 方法返回一个布尔值，表示应用程序是否可以读取文件。如果可以，它返回 true，否则返回 false。

注意：1、canRead() 的结果可能受到多种因素的影响，包括操作系统的文件权限设置、Java虚拟机的安全策略等。
因此，即使 canRead() 返回 true，也不能保证你的应用程序就一定能成功读取该文件。在实际尝试读取文件之前，最好做好错误处理准备。
2、如若返回不读取结果，可能硬盘上文件或文件夹已删除或不存在.

addfile.txt文件是否可以读取结果: true
addfolder文件是否可以读取结果: true

=======================
15、canWrite() 方法返回一个布尔值，表示应用程序是否可以写入文件。如果可以，它返回 true，否则返回 false。

注意：1、canWrite() 的结果可能受到多种因素的影响，包括操作系统的文件权限设置、Java虚拟机的安全策略等。
因此，即使 canWrite() 返回 true，也不能保证你的应用程序就一定能成功写入该文件。在实际尝试写入文件之前，最好做好错误处理准备。
2、如若返回不写入结果，可能硬盘上文件或文件夹已删除或不存在

addfile.txt文件是否可以写入结果: true
addfolder文件是否可以写入结果: true

=======================
16、compareTo(File pathname) 方法按字典顺序比较 2个抽象类实例的路径的字符串表示形式。
(所谓的“字典顺序”，就是基于字符串中各个字符的Unicode值来比较字符串的顺序。)
该方法返回一个整数，其值可能是以下三种情况：
   1、如果当前文件路径（即调用 compareTo() 方法的 File 对象所表示的路径）在字典顺序上位于指定文件路径之前，则返回负整数。
   2、如果两个文件路径相等，则返回零。
   3、如果当前文件路径在字典顺序上位于指定文件路径之后，则返回正整数。
   结果：
addfile.txt在字典顺序上位于addfile_rename.txt之前

提示：这个方法，通常用于判断创建的2个抽象实例对象的路径是否一样，即指向对象是同一个对象。

=======================
17、deleteOnExit 当程序正常退出、通过调用 System.exit() 方法，或者虚拟机由于其他原因被终止时，
deleteOnExit() 方法会尝试删除与该 File 对象关联的文件或文件夹。
testfile_1.txt文件在硬盘上删除
testfolder_1文件夹在硬盘上删除

注意：1、如果文件或文件夹已删除，在运行这个代码，系统不会报错。
2、deleteOnExit() 方法仅提供一个“最佳努力”的删除保证。这意味着当虚拟机终止时，它会尝试删除文件，
但如果出于某种原因（例如文件正在被另一个进程使用）文件无法被删除，那么该文件将保持原样。
此外，依赖于 deleteOnExit() 的代码可能会导致资源泄漏或其他问题，特别是在长时间运行的应用程序或服务器环境中。
因此，在使用此方法时应格外小心。

=======================
18、String[] list() 方法返回一个字符串数组，其中包含当前目录中的所有文件和文件夹的名称。
如果当前目录为空，则返回一个空字符串数组。
如果当前目录不存在，则抛出 FileNotFoundException。
结果：
当前目录中的文件和文件夹名称:
.3.txt
1.txt
2.txt
e.docx
R.txt
----------------------
下面举例错误的显示，因为所以显示文件或文件夹名称不存在硬盘
当前目录中的文件和文件夹名称:
testfile_1.txt
testfolder_1

注意：1、list()方法只适用于文件夹对象。
   2、返回目录（文件夹）里的所有的文件名称和文件夹名称的名称字符串集合(包含隐藏文件或文件夹的名称)(String[])的对象。
   3、如果文件夹里没有文件或文件夹，则返回空NULL.
   3、如果用同一类文件执行在这个文件夹里创建文件或文件夹后删除，否则返回之前删除的文件或文件夹名称

=======================
19、File[] listFiles() 方法返回一个 File实例对象的数组，其中包含当前目录中的所有文件实例对象和文件夹实例对象。
如果当前目录为空，则返回一个空数组。
如果当前目录不存在，则抛出 FileNotFoundException。
结果：
addfolder_1当前目录中的文件和文件夹名称:
.3.txt
1.txt
2.txt
e.docx
R.txt

=======================
20、String[] list(FilenameFilter filter) 指定筛选条件，返回名称集合的字符串集合(String[]) 结果：

addfolder_1当前目录中指定条件为后缀为'.txt'文件名称的集合:
.3.txt
1.txt
2.txt
R.txt

=======================
21、 File[] listFiles(FilenameFilter filter) 指定筛选条件，返回File实例对象的数组结果：

addfolder_1当前目录中指定条件为后缀为'.txt'文件对象集合:
.3.txt
1.txt
2.txt
R.txt

=======================
21、File[] listFiles(FileFilter filter)指定筛选条件，返回File实例对象的数组结果：

true
true
true
false
true
addfolder_1当前目录中指定条件为后缀为'.txt'文件对象集合:
.3.txt
1.txt
2.txt
R.txt

=======================
22、String toPath()方法返回抽象实例对象的路径结果
addfile.txt当前文件路径: D:\笔记记录\io\File\addfile.txt
addfolder当前文件夹路径: D:\笔记记录\io\File\addfolder

=======================
23、File toURL()方法将此抽象路径名转换为文件：URL。
URL的确切形式取决于系统。如果可以确定这个抽象路径名表示的文件是一个目录，
那么生成的URL将以斜线结束。结果:
addfile.txt当前文件File实例对象: file:/D:/笔记记录/io/File/addfile.txt
addfolder当前文件File实例对象: file:/D:/笔记记录/io/File/addfolder/
url.txt当前文件URL: file:/D:/my_javaproject/java_learn/file:/D:/笔记记录/io/File/url.txt
url当前文件URL: file:/D:/my_javaproject/java_learn/file:/D:/笔记记录/io/File/url

注意：1、toURL方法需要与try 一起使用，
2、仅仅是把抽象实例转化为URL
3、此方法已开始被弃用

=======================
24、File getCanonicalFile()方法返回此抽象路径名的规范化文件名，
即为新文件对象或新文件夹对象,需与try 一起使用结果：

addfile.txt当前文件转化为标准路径的新文件对象D:\笔记记录\io\File\addfile.txt
addfolder当前文件夹转化为标准路径的新文件夹对象D:\笔记记录\io\File\addfolder

=======================
25、int hashCode()方法返回哈希值结果：

addfile.txt当前文件哈希值: 69928945
addfolder当前文件夹哈希值: 238881217

=======================
26、boolean setLastModified() 修改最后修改时间结果：
R.txt当前文件，修改状态:true，文件修改后的时间为：2023-12-22 11:13:27
addfolder_1当前文件夹，修改状态:true，文件夹修改后的时间为：2023-12-22 11:13:27
提示：如果想看是否修改成功，可以自己实验的文件或文件夹提前查看最后修改的时间并记下，就可以知道是否修改成功了。