IO_File

Posted 2020-12-02 changzuidaerguai

File类

文件和目录路径名的抽象表示形式。

创建文件或文件夹

import java.io.File;
import java.io.IOException;
/*
 * 创建功能：
 *         createNewFile() ：创建文件，不可分地创建一个新的空文件。
 *         boolean mkdir() ：创建此抽象路径名指定的目录。（创建文件夹） ,如果存在就不创建。
 *      boolean mkdirs() ：创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。 
 * */

public class FileDemo {

    public static void main(String[] args) {
        File f1 = new File("D:\在劫");
        File f2 = new File("D:\在劫\zed.txt");
        //创建文件夹，创建成功返回true
        f1.mkdir();    
        
        try
        /*(f1.mkdir())*/
        {
            //先创建文件夹，再创建文件，创建成功返回true
            f2.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

import java.io.File;

/*    基本获取功能：
         String getAbsolutePath() 
             返回此抽象路径名的绝对路径名字符串。 
         String getPath() 
             将此抽象路径名转换为一个路径名字符串（获取相对路径）。 
         String getName() 
             返回由此抽象路径名表示的文件或目录的名称。 
         long length() 
             返回由此抽象路径名表示的文件的长度。
         long lastModified() 
             返回此抽象路径名表示的文件最后一次被修改的时间。 */
public class FileDemo {

    public static void main(String[] args) {

        File f = new File("在劫\影流之主.jpg");
        //获取绝对路径
        System.out.println("getAbsolutePath: " + f.getAbsolutePath());
        //相对路径
        System.out.println("getPath: " + f.getPath());
        //文件名
        System.out.println("getName: " + f.getName());
        //大小，字节数
        System.out.println("length: " + f.length());
        //最后修改时间
        System.out.println("lastModified: " + f.lastModified());
        
    }
}

import java.io.File;

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

    public static void main(String[] args) {
        //如果是传入（"D:"），这个是无效路径，默认是项目路径
        //(D:\)才代表盘符根目录
        //获取目录下名称方式一
        File f = new File("D:\");
        String[] s = f.list();
        for(String ss : s){
            System.out.println(ss);
        }
        
        //获取目录名称方式二
        File[] f2 = f.listFiles();
        for(File ff : f2){
            System.out.println(ff.getName());
        }
        
    }
}

import java.io.File;

public class FileDemo {

    public static void main(String[] args) {
        //获取目录下名称方式一
        File f = new File("D:\");
/*        String[] s = f.list();
        for(String ss : s){
            System.out.println(ss);
        }*/
        
        //获取目录名称方式二
        //第二种方式返回的是一个File对象，可以通过调用getAbsolutePath()方法得到绝对路径
        File[] f2 = f.listFiles();
        for(File ff : f2){
            System.out.println(ff.getAbsolutePath());
        }
        
    }
}

　判断后缀为".jpg"文件：

import java.io.File;

public class FileDemo {

    public static void main(String[] args) {
        File f = new File("D:\");
        File[] f2 = f.listFiles();
        for(File ff : f2){
            //判断是否是文件
            if(ff.isFile()){
                //判断后缀是否为".jpg"
                if(ff.getName().endsWith(".jpg")){
                    System.out.println(ff.getName());
                    }
                }
            }
    }
}

public class FileDemo {
    /*
          判断后缀是否为".jpg"方式二：
          先判断，是的话放入数组输出
          接口 FilenameFilter
           String[] list(FilenameFilter filter) 
          返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。 
      */
    public static void main(String[] args) {
        File file = new File("D:\");
        String[] strArray = file.list(new FilenameFilter() {
            // 在这里判断是否添加到数组中
            public boolean accept(File dir, String name) {

                File file = new File(dir, name);
                // 判断是否是文件
                boolean flag = file.isFile();
                // 判断是否后缀是".jpg"
                boolean flag2 = name.endsWith(".jpg");
                return flag && flag2;
            }

        });
        // 遍历strArray数组
        // ...

    }
}

简化版

public static void main(String[] args) {
        File file = new File("D:\");
        String[] strArray = file.list(new FilenameFilter() {
            // 在这里判断是否添加到数组中
            public boolean accept(File dir, String name) {
                return new File(dir, name).isFile() && name.endsWith(".jpg");
            }

        });
        // 遍历strArray数组
        // ...

public class FileDemo2 {
    
    //正常的遍历输出所有文件
    public void findAllFile(File f){
        if(f.isDirectory()){
            File[] file = f.listFiles();
　　　　　　　//如果循环遍历file的时候没有使用try...catch语句，编译时有空指针异常
　　　　　　 //因为递归的时候可能会有空指针
            try{
                for(int i = 0; i < file.length; i++){
                    findAllFile(file[i]);
                }
            }catch(Exception e){}    
        }else{
            System.out.println(f);
        }
    }
    
    //有条件的遍历输出所有条件
    public void findAllFile(File f){
        if(f.isDirectory()){
            File[] file = f.listFiles();
　　　　　　　//如果循环遍历file的时候没有使用try...catch语句，编译时有空指针异常
　　　　　　 //因为递归的时候可能会有空指针
            try{
                for(int i = 0; i < file.length; i++){
                    findAllFile(file[i]);
                }
            }catch(Exception e){}    
        }else{
            if(f.isFile() && f.getName().endsWith(".class")){
            System.out.println(f);
            }
        }
    }
    

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        File f = new File("D:\");
        new FileDemo2().findAllFile(f);


    }

}

遍历输出所有文件

public static void findAllFile(File f){
        File[] fileArray = f.listFiles();
        //如果这里没有try...catch语句，会编译时有空指针异常
　　　　 //因为递归的时候可能会有空指针
        try {
            for (File files : fileArray) {
                if (files.isDirectory()) {
                    findAllFile(files);
                } else {
                    System.out.println(files.getAbsolutePath());
                }
            }

        } catch (Exception e) {
        }
    }

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        File f = new File("D:\");
        findAllFile(f);


    }

public static void findAllFile(File f){
        File[] fileArray = f.listFiles();
            for (File files : fileArray) {
                    if (files.isDirectory()) {
                        try{
                            //下面这行方法递归，把这句放到try块中就可以避免输出空指针异常了
                            findAllFile(files);
                            }catch (Exception e){    
                            }
                } else {
                    System.out.println(files.getAbsolutePath());
                }
        }
    }

递归创建路径或文件

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

public class FileDemo {
    /*
     * 判断是否存在某个路径下文件
     *     如果存在路径，则创建文件
     *     如果不存在路径，则创建路径，再创建文件
     * */
    public static void createNewFile(File f){
        //创建新的对象，构造方法(路径目录, 文件名)
        File f2 = new File(f, "zed.txt");
        if(f.exists()){
            try {
                //目录存在，则创建文件
                f2.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }else{
            //如果不存在该目录或文件，则创建
            f.mkdirs();
            //递归
            createNewFile(f);
        }
    }
    public static void main(String[] args) {
        File f = new File("D:\在劫6");
        createNewFile(f);
        
    }
}

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

public class FileDemo {
    /*
     * 判断是否存在某个路径下文件 如果存在路径，则创建文件 如果不存在路径，则创建路径，再创建文件
     */
    public static void createNewFile(File f, File f2) {
        if (f.exists()) {
            try {
                f.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            // 如果不存在该目录或文件，则创建
            f.mkdirs();
            // 递归
            createNewFile(f, f2);
        }
    }

    public static void main(String[] args) {
        File f = new File("D:\在劫3");
        File f2 = new File(f, "zed.txt");
        createNewFile(f, f2);

    }
}

上面这样并不够清晰，导入getParentFile()方法，对该方法返回的值做判断会更好一些。使用这个方法，哪里路径判断，哪里是文件创建一路了然。

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

public class FileDemo {
    /*
     * 判断是否存在某个路径下文件 如果存在路径，则创建文件 如果不存在路径，则创建路径，再创建文件
     *  File getParentFile() 返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。 
     * 
     * 这种方法不用创建多个对象，一个对象完整路径就解决
     * 
     */
    public static void createNewFile(File f) {
        //f.getParentFile()返回父路径名
        //判断父路径目录是否存在，存在的话就创建文件
        if (f.getParentFile().exists()) {
            try {
                f.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            // 如果不存在该目录或文件，则创建父路径
            f.getParentFile().mkdirs();
            // 递归
            createNewFile(f);
        }
    }

    public static void main(String[] args) {
        File f = new File("D:\在劫99", "zed.txt");
        File f2 = new File("D:\在劫101\在劫1011\zed.txt");
        createNewFile(f);
        createNewFile(f2);
    }
}

遍历删除文件

import java.io.File;

public class DeleteDemo {
    public static void deleteTest(File f){
        File[] fArray = f.listFiles();
        for(File ff : fArray){
            if(ff.isDirectory()){
                deleteTest(ff);
            }else{
                //这里是循环遍历文件目录，所以删除的是文件，而不是文件夹
                System.out.println("删除: " + ff.getName() + "---" + ff.delete());
            }
        }
        //递归传入File对象，如果是文件夹就会直接删除
        //先传入 “D:\在劫99”，遍历子目录，子目录如果是文件夹，就方法递归
        //递归传入子目录，如果是文件，就输出名字然后删除(for循环中)
        //然后往下走，删除文件夹（目录必须为空的情况下才能删除）
        
        //这里才是删除文件夹的
        System.out.println("删除文件夹： " + f.getName() + "---" + f.delete());
    }

    public static void main(String[] args) {
        File f = new File("D:\在劫100");
        deleteTest(f);
    }

}