• File类与IO流
  • File类的静态成员变量
  • 绝对路径和相对路径
  • File类的构造方法
  • File类获取功能的方法
  • File类判断功能的方法
  • File类创建和删除功能的方法
  • File类的目录的遍历功能

File类与IO流

java.lang.Object
java.io.File

java把电脑中的文件，文件夹（目录）封装成了一个File类，我们可以使用File类对文件和文件夹进行操作

可以使用File类的方法去：

​ 创建一个文件/文件夹

​ 删除文件/文件夹

​ 获取文件/文件夹

​ 判断文件/文件夹是否存在

​ 对文件夹进行遍历

​ 获取文件的大小

File类是一个与系统无关的类，任何操作系统都可以使用这个类中的方法

重点：记住3个单词

1. file:文件
2. directory：文件夹/目录
3. path：路径

File类的静态成员变量

public class DemosFile {
    public static void main(String[] args) {
        String pathSeparator = File.pathSeparator;
        System.out.println(pathSeparator);//文件名称分隔符：windows：反斜杠 Linux：正斜杠/
        char pathSeparatorChar = File.pathSeparatorChar;
        System.out.println(pathSeparatorChar);//文件名称分隔符：windows：反斜杠 Linux：正斜杠/

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


        /*操作路径不能写死了
        *   例如：
        *       C:\Users\98398\Desktop\我的MarkDown文件     Windows
        *       C:/Users/98398/Desktop/我的MarkDown文件     Linnux
        *正确写法：
        *       "C:"+File.separator+"User"+File.separator+"a"+File.separator+"a.png"
        *
        * */
    }
}

绝对路径和相对路径

路径：

​ 绝对路径：是一个完整的路径

​ 以盘符开始的路径

​ 相对路径：是一个简化的路径

​ 相对指的是相对于当前项目的根目录

​ 如果使用当前项目的根目录，路径可以简化书写（可以省略根目录不写）

​ 注意：

	1. 路径不区分大小写
	2. 路径中文件名称分隔符Windows使用反斜杠，反斜杠是转义字符，两个反斜杠代表一个普通的反斜杠

File类的构造方法

import java.io.File;

public class DemosFile2 {
    /**
     * File类的构造方法
     */
    public static void main(String[] args) {
        show1();
        show2("C:\\","c.txt ");
        show3();

    }

    private static void show3() {
        File parent = new File("C:\\");
        File file3 = new File(parent, "d.java");
        System.out.println(file3);
    }

    private static void show2(String a,String b) {
        File file2 = new File(a, b);
        System.out.println(file2);
    }

    private static void show1() {
        File file1 = new File("C:\\Users\\98398\\Desktop\\我的MarkDown文件\\a.txt");
        System.out.println(file1);

        File file2 = new File("C:\\Users\\98398\\Desktop\\我的MarkDown文件");
        System.out.println(file2);

        File file3 = new File("b.txt");
        System.out.println(file3);
    }
}

File类获取功能的方法

方法摘要
boolean canExecute()
测试应用程序是否可以执行此抽象路径名表示的文件。
boolean canRead()
测试应用程序是否可以读取此抽象路径名表示的文件。
boolean canWrite()
测试应用程序是否可以修改此抽象路径名表示的文件。
int compareTo(File pathname)
按字母顺序比较两个抽象路径名。
boolean createNewFile()
当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
static File createTempFile(String prefix, String suffix)
在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。
static File createTempFile(String prefix, String suffix, File directory)
在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。
boolean delete()
删除此抽象路径名表示的文件或目录。
void deleteOnExit()
在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。
boolean equals(Object obj)
测试此抽象路径名与给定对象是否相等。
boolean exists()
测试此抽象路径名表示的文件或目录是否存在。
File getAbsoluteFile()
返回此抽象路径名的绝对路径名形式。
String getAbsolutePath()
返回此抽象路径名的绝对路径名字符串。
File getCanonicalFile()
返回此抽象路径名的规范形式。
String getCanonicalPath()
返回此抽象路径名的规范路径名字符串。
long getFreeSpace()
返回此抽象路径名指定的分区中未分配的字节数。
String getName()
返回由此抽象路径名表示的文件或目录的名称。
String getParent()
返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
File getParentFile()
返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。
String getPath()
将此抽象路径名转换为一个路径名字符串。
long getTotalSpace()
返回此抽象路径名指定的分区大小。
long getUsableSpace()
返回此抽象路径名指定的分区上可用于此虚拟机的字节数。
int hashCode()
计算此抽象路径名的哈希码。
boolean isAbsolute()
测试此抽象路径名是否为绝对路径名。
boolean isDirectory()
测试此抽象路径名表示的文件是否是一个目录。
boolean isFile()
测试此抽象路径名表示的文件是否是一个标准文件。
boolean isHidden()
测试此抽象路径名指定的文件是否是一个隐藏文件。
long lastModified()
返回此抽象路径名表示的文件最后一次被修改的时间。
long length()
返回由此抽象路径名表示的文件的长度。
String[] list()
返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
String[] list(FilenameFilter filter)
返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[] listFiles()
返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
File[] listFiles(FileFilter filter)
返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[] listFiles(FilenameFilter filter)
返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
static File[] listRoots()
列出可用的文件系统根。
boolean mkdir()
创建此抽象路径名指定的目录。
boolean mkdirs()
创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
boolean renameTo(File dest)
重新命名此抽象路径名表示的文件。
boolean setExecutable(boolean executable)
设置此抽象路径名所有者执行权限的一个便捷方法。
boolean setExecutable(boolean executable, boolean ownerOnly)
设置此抽象路径名的所有者或所有用户的执行权限。
boolean setLastModified(long time)
设置此抽象路径名指定的文件或目录的最后一次修改时间。
boolean setReadable(boolean readable)
设置此抽象路径名所有者读权限的一个便捷方法。
boolean setReadable(boolean readable, boolean ownerOnly)
设置此抽象路径名的所有者或所有用户的读权限。
boolean setReadOnly()
标记此抽象路径名指定的文件或目录，从而只能对其进行读操作。
boolean setWritable(boolean writable)
设置此抽象路径名所有者写权限的一个便捷方法。
boolean setWritable(boolean writable, boolean ownerOnly)
设置此抽象路径名的所有者或所有用户的写权限。
String toString()
返回此抽象路径名的路径名字符串。
URI toURI()
构造一个表示此抽象路径名的 file: URI。
URL toURL()
已过时。 此方法不会自动转义 URL 中的非法字符。建议新的代码使用以下方式将抽象路径名转换为 URL：首先通过 toURI 方法将其转换为 URI，然后通过 URI.toURL 方法将 URI 装换为 URL。

import java.io.File;

public class DemosFile3 {
    /**
     * String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
     * String getName() 返回由此抽象路径名表示的文件或目录的名称。
     * String getPath() 将此抽象路径名转换为一个路径名字符串。
     * long length() 返回由此抽象路径名表示的文件的长度。
     */
    public static void main(String[] args) {
        show1();
        System.out.println("———————————————————————————————————");
        show2();
        System.out.println("———————————————————————————————————");
        show3();
        System.out.println("———————————————————————————————————");
        show4();

    }
/*long length() 返回由此抽象路径名表示的文件的长度。
* 此方法获取的是构造方法中指定的文件的大小，以字节为单位
* 注意：
*       1.只能获取文件的大小，无法获取文件夹的大小
*       （因为计算机中文件夹的大小属性是没有值的
*       我们可以通过属性去查看文件夹的大小，但是看到的大小值其实是该文件夹里所有文件的大小总和）
*
*       2.如果构造方法中给出的路径不存在，那么length()方法返回的就是0*/
    private static void show4() {
        File file1 = new File("C:\\Users\\98398\\Desktop\\我的截图\\hahaahahah.jpg");//真实存在的文件（绝对路径）
        long length1 = file1.length();//获取到的是文件大小
        System.out.println(length1);

        File file2 = new File("pom.xml");//真实存在的文件（相对路径）
        long length2 = file2.length();//获取到的是文件大小
        System.out.println(length2);

        File file3 = new File("wuwuwuwuwu.jpg");//不存在的文件
        long length3 = file3.length();//文件不存在，获取到的返回值是0
        System.out.println(length3);

        File file4 = new File("E:\\IdeaProjects\\spring-study\\poker");//真实存在的文件夹
        long length4 = file4.length();//文件夹存在，获取到的返回值是0
        System.out.println(length4);

        File file5 = new File("E:\\IdeaProjects\\spring-study\\poker");//不存在的文件夹
        long length5 = file5.length();//文件夹不存在，获取到的返回值是0
        System.out.println(length5);


    }

    /*String getName() 返回由此抽象路径名表示的文件或目录的名称。
* 此方法获取的是构造方法中传递的路径
* getName()方法返回的是路径的结尾部分*/
    private static void show3() {
        File file1 = new File("E:\\IdeaProjects\\spring-study\\a.txt");//结尾是文件名(绝对路径)
        String name1 = file1.getName();//获取到的是文件名
        System.out.println(name1);

        File file2 = new File("E:\\IdeaProjects\\spring-study");//结尾是文件夹名(绝对路径)
        String name2 = file2.getName();//获取到的是文件夹名
        System.out.println(name2);

        File file3 = new File("a.txt");//结尾是文件夹名(相对路径)
        String name3 = file3.getName();//获取到的是文件夹名
        System.out.println(name3);
    }

    /*String getPath() 将此抽象路径名转换为一个路径名字符串。
* 此方法获取的是构造方法中传递的路径
* 路径是什么，getPath()方法就返回什么
*
* toString调用的就是getPath()方法*/
    private static void show2() {
        File file1 = new File("E:\\IdeaProjects\\spring-study\\a.txt");//绝对路径
        String path1 = file1.getPath();//获取到的就是绝对路径
        System.out.println(path1);

        File file2 = new File("a.txt");//相对路径
        String path2 = file2.getPath();//获取到的就是相对路径
        System.out.println(path2);

        System.out.println(file1.toString());//toString调用的就是getPath()方法
        System.out.println(file2.toString());//toString调用的就是getPath()方法
    }

    /*String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
* 此方法获取的是构造方法中传递的路径
* 无论路径是绝对路径还是相对路径，getAbsolutePath()方法返回的都是 绝对路径 */
    private static void show1() {
        File file1 = new File("E:\\IdeaProjects\\spring-study\\a.txt");//绝对路径
        String absolutePath1 = file1.getAbsolutePath();//获取到的是绝对路径
        System.out.println(absolutePath1);

        File file2 = new File("a.txt");//相对路径
        String absolutePath2 = file2.getAbsolutePath();//获取到的还是绝对路径
        System.out.println(absolutePath2);
    }



}

运行结果：

File类判断功能的方法

boolean isDirectory()
测试此抽象路径名表示的文件是否是一个目录。

boolean isFile()
测试此抽象路径名表示的文件是否是一个标准文件。

boolean exists()
测试此抽象路径名表示的文件或目录是否存在。

import java.io.File;

public class DemosFile4 {
    /*
File类判断功能的方法
    boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
    boolean isDirectory() 测试此抽象路径名表示的文件是否是一个目录。
    boolean isFile() 测试此抽象路径名表示的文件是否是一个标准文件。


*/
    public static void main(String[] args) {
        show1();
        System.out.println("———————————————————————————————————");
        show2();
    }

    private static void show3() {

    }

    /**
     * boolean isDirectory() 测试此抽象路径名表示的文件是否是一个目录。
     *  用于判断构造方法中路径是否以文件夹结尾
     *      是：true
     *      否：false
     *
     *boolean isFile() 测试此抽象路径名表示的文件是否是一个标准文件。
     *  用于判断构造方法中路径是否以文件结尾
     *      是：true
     *      否：false
     *
     *      注意：
     *          电脑硬盘中只有文件或文件夹，所以两个方法是互斥的
     *          这两个方法的使用前提是，路径必须是真实存在的，否则都返回false
     */
    private static void show2() {
        File file1 = new File("E:\\IdeaProjects\\spring-studyxxxx");//不存在的绝对路径
        System.out.println(file1.isDirectory());//false
        System.out.println(file1.isFile());//false

        //代码优化
        //先判断路径存不存在，如果路径不存在就没有必要获取
        if(file1.exists()){//路径不存在，不执行下面两行代码
            System.out.println(file1.isDirectory());
            System.out.println(file1.isFile());
        }

        File file2 = new File("E:\\IdeaProjects\\spring-study");//真实存在的绝对路径，结尾是文件夹
        if(file2.exists()){
            System.out.println(file2.isDirectory());//结尾是文件夹,所以返回值是true
            System.out.println(file2.isFile());//结尾是文件夹不是文件,所以返回值是false
        }

        File file3 = new File("E:\\IdeaProjects\\spring-study\\FileAndIO\\pom.xml");//真实存在的绝对路径，结尾是文件
        if(file3.exists()){
            System.out.println(file3.isDirectory());//结尾是文件不是文件夹,所以返回值是false
            System.out.println(file3.isFile());//结尾是文件,所以返回值是true
        }



    }

    /**
     * boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
     * 用于判断构造方法中路径是否存在
     * 返回值类型是boolean
     * 存在：true
     * 不存在：false
     */
    private static void show1() {
        File file1 = new File("E:\\IdeaProjects\\spring-study");//真实存在的绝对路径
        boolean exists1 = file1.exists();//存在则返回true
        System.out.println(exists1);

        File file2 = new File("E:\\IdeaProjects\\spring-studyxxxx");//不存在的绝对路径
        boolean exists2 = file2.exists();//不存在则返回false
        System.out.println(exists2);

        File file3 = new File("pom.xml");//真实存在的相对路径
        boolean exists3 = file3.exists();//存在则返回true
        System.out.println(exists3);

        File file4 = new File("pomxxx.xml");//不存在的相对路径
        boolean exists4 = file4.exists();//不存在则返回false
        System.out.println(exists4);
    }
}

运行结果：

File类创建和删除功能的方法

boolean createNewFile()
当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。

boolean delete()
删除此抽象路径名表示的文件或目录。

boolean mkdir()
创建此抽象路径名指定的目录。

boolean mkdirs()
创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。

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

public class DemosFile5 {
    /*
    boolean createNewFile() 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
    boolean delete() 删除此抽象路径名表示的文件或目录。
    boolean mkdir() 创建此抽象路径名指定的目录。
    boolean mkdirs() 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。


    */
    public static void main(String[] args) throws IOException {
        show1();
        show2();
        show3();
    }
/*
* boolean delete() 删除此抽象路径名表示的文件或目录。
* 此方法，可以删除构造方法路径中的文件也可以删除构造方法路径中的文件夹
* 返回值：
*   true:文件/文件夹删除成功，返回true
*   false:文件夹中有内容，就不会删除文件文件夹，返回false;或者构造方法中路径是错的，路径不存在，就删除不了，也会返回false
* 注意事项：
*   delete方法是直接从硬盘删除文件/文件夹，不会经过回收站，所以使用此方法要谨慎，避免删除重要文件导致不必要的损失
* */
    private static void show3() throws IOException {
        File file1 = new File("FileAndIO\\src\\main\\java\\a");//构造方法路径所表示的文件/文件夹就是要删除的对象
        boolean b1 = file1.delete();//a文件夹被删除
        System.out.println("b1:"+b1);//true

        File file2 = new File("FileAndIO\\src\\main\\java\\a.txt");//构造方法路径所表示的文件/文件夹就是要删除的对象
        boolean b2 = file2.delete();//a.txt文件被删除
        System.out.println("b2:"+b2);//true

        File file3 = new File("FileAndIO\\src\\main\\java\\asasas.txt");//构造方法路径所表示的文件/文件夹就是要删除的对象
        boolean b3 = file3.delete();//文件不存在或路径错误，删除失败
        System.out.println("b3:"+b3);//false

        //先再abc.txt文件夹里放点东西，我随便创建了一个.java文件
        File file4 = new File("FileAndIO\\src\\main\\java\\abc.txt\\a.txt");//绝对路径
        System.out.println(file4.createNewFile());//true

        File file5 = new File("FileAndIO\\src\\main\\java\\abc.txt");//构造方法路径所表示的文件/文件夹就是要删除的对象
        boolean b5 = file5.delete();//文件夹中有内容，无法删除文件夹
        System.out.println("b5:"+b5);//false

    }

    /*  boolean mkdir() 创建此抽象路径名指定的目录。
        boolean mkdirs() 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
        创建文件的路径和名称再构造方法中给出（构造方法的参数）
         * 返回值：
         *  true:文件夹不存在，不会创建，返回true
         *  false：文件夹存在，不会创建，返回false
         * 注意：
         *      1.此方法只能创建文件夹，不能创建文件
        */
    private static void show2() {
        File file1 = new File("FileAndIO\\src\\main\\java\\a");//只要路径存在，文件夹名字唯一，就能创建成功
        boolean mkdir1 = file1.mkdir();
        System.out.println("mkdir1："+mkdir1);//true

        File file2 = new File("FileAndIO\\src\\main\\java\\a\\b\\c\\d");//无法创建一个有一个嵌套的文件夹
        boolean mkdir2 = file2.mkdir();
        System.out.println("mkdir2："+mkdir2);//false

        File file3 = new File("FileAndIO\\src\\main\\java\\abc.txt");//创建的还是一个文件夹，abc.txt是文件夹的名字
        boolean mkdir3 = file3.mkdir();
        System.out.println("mkdir3："+mkdir3);//true

        File file4 = new File("Fil\\ccc.txt");//路径错误，无法创建，但是这个方法没有异常抛出
        boolean mkdir4 = file4.mkdir();
        System.out.println("mkdir4："+mkdir4);//false



    }

    /**
     *boolean createNewFile() 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
     * 创建文件的路径和名称再构造方法中给出（构造方法的参数）
     * 返回值：
     *  true:文件不存在，不会创建，返回true
     *  false：文件存在，不会创建，返回false
     * 注意：
     *      1.此方法只能创建文件，不能创建文件夹
     *      2.创建文件的路径必须存在，否则会抛出异常
     */
    private static void show1() throws IOException {
        File file1 = new File("E:\\IdeaProjects\\spring-study\\FileAndIO\\src\\main\\java\\a.txt");//绝对路径
        boolean b1 = file1.createNewFile();
        System.out.println("b1:"+b1);//true

        File file2 = new File("FileAndIO\\src\\main\\java\\b.txt");//绝对路径
        System.out.println(file2.createNewFile());//true
    }
}

运行结果：

File类的目录的遍历功能

String[] list()
返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
File[] listFiles()
返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

import java.io.File;

public class DemosFile6 {
    /*
    String[] list()
            返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
    File[] listFiles()
            返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

            注意：
                list方法和listFiles方法遍历的是构造方法中给出的目录
                如果构造方法中给出的目录的路径不存在，就会抛出空指针异常
                如果构造方法中给出的路径不是一个目录，也会抛出空指针异常

          */
    public static void main(String[] args) {
        show1();
        show2();
    }
/*File[] listFiles()
            返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
        此方法会遍历构造方法中给出的目录，会获取目录中所有文件/文件夹的名称，把获取到的所有文件/文件夹封装为File对象并存储到File数组中
            */
    private static void show2() {
        File file1 = new File("E:\\IdeaProjects\\spring-study\\FileAndIO\\src\\main\\java");
        File[] files = file1.listFiles();
        System.out.println(files);
        for (File file : files) {
            System.out.println(file);
        }
    }

    /*String[] list()
                返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
      此方法会遍历构造方法中给出的目录，会获取目录中所有文件/文件夹的名称，把获取到的多个名称存储到一个String类型的数组中*/
    private static void show1() {
        File file1 = new File("E:\\IdeaProjects\\spring-study\\FileAndIO\\src\\main\\java");
        String[] list1 = file1.list();
        System.out.println(list1);

        //遍历打印list1数组
        for (String s : list1) {
            System.out.println(s);
        }
    }
}

运行结果：