Java之File类总结

最新推荐文章于 2022-07-27 01:29:32 发布

ethannotlazy

最新推荐文章于 2022-07-27 01:29:32 发布

阅读量157

点赞数

分类专栏： Java 文章标签：过滤器字符串 java filter lambda

本文链接：https://blog.csdn.net/weixin_43116322/article/details/103649806

版权

Java 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

分隔符

路径分隔符：
1.windows: ’ ; ’ 2.linux: ’ : ’
名称分隔符：
1.windows: ’ \ ’ 2.linux: ’ / ’

public class Demo01Separator {
    public static void main(String[] args) {
        /*
        static String pathSeparator 路径分隔符，windows:";' linux:":"
        static char pathSeparatorChar
        static String separator 默认名称分隔符，windows:"\" linux:"/"
        static char separatorChar
         */
        String pathSeparator = File.pathSeparator;
        String separator = File.separator;
        System.out.println(pathSeparator);
        System.out.println(separator);
    }
}

路径

分为绝对路径、相对路径：

/*
路径：
1.绝对路径，从盘符开始
2.相对路径，从当前根目录开始
注意：
1.路径不区分大小写
2.路径中的文件名称分隔符"\"是转义字符，两个'\"代表一个"\"
 */
public class Demo02Path {
    public static void main(String[] args) {
        method1();
        method2();
        method3();
    }

    /*
    File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建一个File实例
    参数：
        可以是以文件结尾，也可以是文件夹结尾
        可以是相对路径，也可以是绝对路径
        路径可以存在也可以不存在
        创建File对象，只是把字符串封装为File对象，不考虑路径的真假情况
     */
    private static void method1() {
        File file1 = new File("c:\\user\\a.txt");
        File file2 = new File("c:\\user");
        File file3 = new File("b.txt");
    }

    private static void method2() {
        /*
        File(String parent, String child)根据parent路径和child路径创建一个File实例
        好处：父路径和子路径单独写，使用灵活
         */
        String parent = "C:\\";
        String child = "a.txt";
        File file = new File(parent, child);
    }

    private static void method3() {
        File parent = new File("C:\\");
        File file = new File(parent, "a.txt");
    }
}

返回路径的方法

public class Demo03GetFilePath {
    public static void main(String[] args) {
        method1();
        method2();
        method3();
        method4();
    }

    /*
    public String getAbsolutePath()返回绝对路径
     */
    private static void method1() {
        File file1 = new File("D:\\cs\\a.txt");
        String path1 = file1.getAbsolutePath();
        System.out.println(path1);
        File file2 = new File("a.txt");
        String path2 = file2.getAbsolutePath();
        System.out.println(path2);
    }

    /*
    public String getPath()返回封装的路径
     */
    private static void method2() {
        File file1 = new File("D:\\cs\\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());   //实际上是file.getPath()
    }

    /*
    public String getName()返回File对象表示的文件或目录
     */
    private static void method3() {
        File file1 = new File("D:\\cs\\a.txt");
        System.out.println(file1.getName());
        File file2 = new File("a.txt");
        System.out.println(file2.getName());
        File file3 = new File("D:\\cs");
        System.out.println(file3.getName());
    }

    /*
    public long length()返回此File对象表示的文件的长度，以字节为单位
    注意：
        1.文件夹没有大小，不能获取文件夹的大小
        2.如果路径不存在，那么length()返回0
     */
    private static void method4() {
        File file1 = new File("D:\\work_space\\Project01\\example.txt"); //返回以字节为单位的文件大小
        long length1 = file1.length();
        System.out.println(length1);
        File file2 = new File("D:\\cs\\b.txt"); //不存在的文件，返回0
        long length2 = file2.length();
        System.out.println(length2);
        File file3 = new File("D:\\cs");    //文件夹，返回0
        long length3 = file3.length();
        System.out.println(length3);
    }
}

文件的存在和路径的判断

public class Demo04FileJudge {
    public static void main(String[] args) {
        method1();
        method2();
    }

    /*
    public boolean exist()文件或目录存在则返回true，否则返回false
     */
    public static void method1(){
        File file1 = new File("D:\\work_space\\Project01\\example.txt");
        System.out.println(file1.exists());
        File file2 = new File("D:\\cs\\b.txt");
        System.out.println(file2.exists());
    }

    /*
    public boolean isDirectory()：如果给定路径以文件夹结尾，则返回true，否则返回false
    使用前提：路径存在，否则返回false
     */
    public static void method2(){
        File file1 = new File("D:\\cs\\a.txt");
        System.out.println(file1.isDirectory());
        File file2 = new File("D:\\cs");
        System.out.println(file2.isDirectory());
        File file3 = new File("D:\\cs\\cs");    //路径不存在，返回false
        System.out.println(file3.isDirectory());
    }
}

文件的创建和删除

public class Demo05CreateDelete {
    public static void main(String[] args) throws IOException {
        method2();
        method3();
        method1();
    }

    /*
    public boolean createNewFile()：当且仅当文件不存在时，创建一个新的空文件
    文件不存在时，创建文件，返回true
    文件存在时，不创建，返回false
    注意：
        1.只能创建文件，不能创建文件夹
        2.创建文件的路径必须存在，否则抛出异常
        3.方法抛出IOException，调用的方法必须处理或继续抛出异常
     */
    public static void method1() throws IOException {
        File file1 = new File("D:\\work_space\\Project01\\example.txt");    //文件存在
        boolean createFile1 = file1.createNewFile();
        System.out.println(createFile1);
        File file2 = new File("example1.txt");
        boolean createFile2 = file2.createNewFile();    //创建了example1.txt
        System.out.println(createFile2);
        File file3 = new File("D:\\work_space\\Project001\\example.txt");
        file3.createNewFile();  //路径不存在，抛出异常
    }

    /*
    public boolean mkdir(): 创建单级文件夹
    public boolean mkdirs()：既可以创建多级文件夹，也可以创建多级文件夹
    文件夹不存在，创建文件夹，返回true
    文件夹存在，不会创建，返回false
    注意：
        只能创建文件夹，不能创建文件
     */
    public static void method2() {
        File file1 = new File("D:\\work_space\\Project01\\mk_example");
        boolean md1 = file1.mkdir();
        System.out.println(md1);
        File file2 = new File("D:\\work_space\\Project01\\mk_example\\111\\222\\333");  //路径不存在
        boolean md2 = file2.mkdir();
        System.out.println(md2);
        boolean md3 = file2.mkdirs();
        System.out.println(md3);
    }

    /*
    public boolean delete()：删除此File表示的文件或目录
    删除成功：返回true
    文件夹中有文件，不会删除，返回false
    路径不存在，返回false
    注意：delete()直接在硬盘删除，不进入回收站
     */
    public static void method3() {
        File f1 = new File("D:\\work_space\\Project01\\mk_example");    //文件夹内还有文件或文件夹，删除失败
        f1.delete();
        File f2 = new File("example1.txt");
        f2.delete();
    }
}

文件的遍历

public class Demo06Traversal {
    public static void main(String[] args) {
        method1();
        method2();
    }

    /*
    public string[] list()：返回一个String数组，表示该File目录下所有子文件或目录
    如果File路径是文件或路径不存在，方法抛出异常
     */
    public static void method1(){
        File file = new File("D:\\work_space\\Project01");
        String[] files = file.list();
        for (String s : files) {
            System.out.println(s);
        }
    }
    /*
    public File[] listFiles()：返回一个File数组，表示该File目录中的所有子文件或目录
     */
    public static void method2(){
        File file = new File("D:\\work_space\\Project01");
        File[] files = file.listFiles();
        for (File f : files) {
            System.out.println(f.getPath());
        }
    }
}

递归遍历所有目录

public class Demo07RecursionPrint {
    public static void main(String[] args) {
        File dir = new File("D:\\");
        printAllFiles(dir);
    }

    public static void printAllFiles(File dir){
        /*
        Returns
               {@code null} if this abstract pathname does not denote a
               directory, or if an I/O error occurs.
         */
        File[] temp = dir.listFiles();
        if(temp == null)
            return;
        for (File file : temp) {
            System.out.println(file);
            if(file.isDirectory())
                printAllFiles(file);
        }
    }
}

递归查找文件

public class Demo08SearchFile {
    public static void main(String[] args) {
        File file = new File("D:\\work_space\\Project01");
        ArrayList<File> res = searchFiles(new ArrayList<File>(), file);
        for (File f : res) {
            System.out.println(f.getAbsolutePath());
        }
    }
    //输出目录下的所有.java文件，要求包括子目录内的.java文件
    private static ArrayList<File> searchFiles(ArrayList<File> res, File file){
        File[] files = file.listFiles();
        for (File f : files) {
            if(f.isDirectory()){
                searchFiles(res, f);
                continue;
            }
            if(f.getPath().toLowerCase().endsWith(".java"))
                res.add(f);
        }
        return res;
    }
}

过滤器

FileFilter接口的实现：

/*
可以使用过滤器实现遍历
File类有两个listFile()重载的方法，方法的参数是过滤器
File[] listFiles(FileFilter filter)
java.io.FileFilter接口：用于抽象路径名的过滤器
boolean accept(File pathname)测试指定路径名是否在某个应该包含在某个路径名列表中

java.io.filenameFilter接口：实现此接口的类实例可用于过滤文件名
boolean accept(File dir, String name)测试指定文件是否应该包含在某一文件列表中
注意：
    两个过滤器没有实现类，需要自己写实现类，重写过滤方法accept()
 */
public class Demo09Filter {
    public static void main(String[] args) {
        File f = new File("D:\\work_space\\Project01");
        printFiles(f);
        System.out.println("-------------------------------------------------------");
        printFilesOptimized(f);
        //用匿名内部类构造过滤器
        f.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return true;
            }
        });

        //Lambda表达式，如果是目录则加入File数组
        f.listFiles((pathname) -> pathname.isDirectory());
    }

    //输出目录下的所有.java文件，要求包括子目录内的.java文件
    private static void printFiles(File file){
        /*
        listFiles()方法做了三件事：
            1.对路径进行遍历，获取每一个文件、文件夹，并封装为File对象
            2.调用过滤器的accept()方法
            3.每个对象的路径作为filename参数传递给accept()方法
         */
        File[] files = file.listFiles(new FileFilterImpl());
        for (File f : files) {
            if(f.isDirectory()){
                printFiles(f);
            }else System.out.println(f);
        }
    }

    private static void printFilesOptimized(File file){
        for(File f: file.listFiles(pathname -> pathname.isDirectory() || pathname.getPath().toLowerCase().endsWith(".java")))
            if(f.isDirectory())
                printFilesOptimized(f);
            else System.out.println(f.getAbsolutePath());
    }
}

class FileFilterImpl implements FileFilter {

    @Override
    public boolean accept(File pathname) {
        return pathname.isDirectory() || pathname.getPath().toLowerCase().endsWith(".java");
    }
}

FilenameFilter接口的实现：

public class Demo10FilenameFilter {
    public static void main(String[] args) {
        File file = new File("D:\\work_space\\Project01");
        findJava(file);
        System.out.println("----------------------------------------");
        findJavaOptimized(file);
    }

    public static void findJava(File file){
        File[] files = file.listFiles(new FilenameFilterImpl());
        for (File f : files) {
            if(f.isDirectory())
                findJava(f);
            else System.out.println(f.getAbsolutePath());
        }
    }

    public static void findJavaOptimized(File file){
        for(File f: file.listFiles((dir, name) -> name.toLowerCase().endsWith(".java") || new File(dir, name).isDirectory()))
            if(f.isDirectory())
                findJava(f);
            else System.out.println(f.getAbsolutePath());
    }
}

class FilenameFilterImpl implements FilenameFilter {

    @Override
    public boolean accept(File dir, String name) {
        return name.toLowerCase().endsWith(".java") || new File(dir, name).isDirectory();
    }
}

		// 第一种：获取类加载的根路径   D:\IDEAWorkspace\hs-bluetooth-lock\src\applications\bluetooth-api\target\classes
        File f = new File(this.getClass().getResource("/").getPath());
        System.out.println(f);

        // 获取当前类的所在工程路径; 如果不加“/”  获取当前类的加载目录  D:\IDEAWorkspace\hs-bluetooth-lock\src\base\target\classes\com\hs\lock\bluetooth\base\utils
        File f2 = new File(this.getClass().getResource("").getPath());
        System.out.println(f2);

        // 第二种：获取项目路径    D:\IDEAWorkspace\hs-bluetooth-lock
        File directory = new File("");// 参数为空
        String courseFile = directory.getCanonicalPath();
        System.out.println(courseFile);

        // 第三种：  file:/D:/IDEAWorkspace/hs-bluetooth-lock/src/applications/bluetooth-api/target/classes/
        URL xmlpath = this.getClass().getClassLoader().getResource("");
        System.out.println(xmlpath);

        // 第四种： 获取当前工程路径 D:\IDEAWorkspace\hs-bluetooth-lock
        System.out.println(System.getProperty("user.dir"));
  
        // 第五种：  获取所有的类路径 包括jar包的路径
        System.out.println(System.getProperty("java.class.path"));

ethannotlazy

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java之File类总结

分隔符路径分隔符：1.windows:’;’ 2.linux:’:’名称分隔符：1.windows:’’ 2.linux:’/’public class Demo01Separator { public static void main(String[] args) { /* static String pathSeparator 路径分隔符，wi...
复制链接

扫一扫