Java--File文件操作

待我称王封你为后i 2022-05-21 10:40 233阅读 0赞

### 判断文件或目录是否存在 ###

判断File对象所指向的文件或者目录是否存在，使用exists()函数。

File f = new File("/Users/bemaster/Desktop/in.txt");
    System.out.println(f.exists());

# 判断当前File对象是文件还是目录 #

判断当前File对象是否是文件，使用isFile()函数。

判断当前File对象是否是目录，使用isDirectory()函数。

![复制代码][copycode.gif]

File f = new File("/Users/bemaster/Desktop/in.txt");
    File f2 = new File("/Users/bemaster/Desktop/in.txt");
    if(f.isFile())
        System.out.println("is file!!!");
    if(f2.isDirectory())
        System.out.println("is directory!!!");

![复制代码][copycode.gif]

# 新建文件或目录 #

新建文件，使用createNewFile()函数

![复制代码][copycode.gif]

File f = new File("/Users/bemaster/Desktop/in.txt");
    try {
        if(!f.exists())
            f.createNewFile();
    } catch (IOException e) {
    // TODO Auto-generated catch block
        e.printStackTrace();
    }

![复制代码][copycode.gif]

新建目录，使用mkdir()或者mkdirs()函数。区别是前者是新建单级目录，而后者是新建多级目录。

即如果新建目录时，如果上一级目录不存在，那么mkdir()是不会执行成功的。

![复制代码][copycode.gif]

/*如果User目录，或者bemaster目录，或者Desktop目录不存在，
    * 如果使用mkdir(),则新建tmp目录失败
    * 如果使用mkdirs()，则连不存在的上级目录一起新建
    */
    File f = new File("/Users/bemaster/Desktop/tmp");
    if(!f.exists())
        f.mkdir();

![复制代码][copycode.gif]

# 获取当前目录下的所有文件 #

list()函数返回当前目录下所有文件或者目录的名字（即相对路径）。

listFiles()函数返回当前目录下所有文件或者目录的File对象。

很显然，list()函数效率比较高，因为相比于listFiles()函数少了一步包装成File对象的步骤。

上面的两个函数都有另外一个版本，可以接受一个过滤器，即返回那么满足过滤器要求的。

public String[] list();
    public String[] list(FilenameFilter filter);
    public File[] listFiles();
    public File[] listFiles(FileFilter filter);
    public File[] listFiles(FilenameFilter filter);

# 删除文件或目录 #

删除文件或目录都是使用delete()，或者deleteOnExit()函数，但是如果目录不为空，则会删除失败。

delete()和deleteOnExit()的区别是前者立即删除，而后者是等待虚拟机退出时才删除。

File f = new File("/Users/bemaster/Desktop/in.txt");
    f.delete();

如果想要删除非空的目录，则要写个函数递归删除。

![复制代码][copycode.gif]

/**
         * 
         *<删除文件或者目录，如果目录不为空，则递归删除
         * @param file filepath 你想删除的文件
         * @throws FileNotFoundException 如果文件不存在，抛出异常
         * 
         */
        public static void delete(File file) throws FileNotFoundException {
            if(file.exists()){
                File []fileList=null;
                //如果是目录，则递归删除该目录下的所有东西
                if(file.isDirectory() && (fileList=file.listFiles()).length!=0){
                    for(File f:fileList)
                        delete(f);
                }
                //现在可以当前目录或者文件了
                file.delete();
            }
            else{
                throw new FileNotFoundException(file.getAbsolutePath() + "is not exists!!!");
            }
        }

![复制代码][copycode.gif]

# 重命名（移动）文件或目录 #

重命名文件或目录是使用renameTo(File)函数，如果想要移动文件或者目录，只需要改变其路径就可以做到。

File f = new File("/Users/bemaster/Desktop/in.txt");
    f.renameTo(new File("/Users/bemaster/Desktop/in2.txt"));

# 复制文件或目录 #

File类不提供拷贝文件或者对象的函数，所以需要自己实现。

![复制代码][copycode.gif]

/**
         * through output write the byte data which read from input  
         * 将从input处读取的字节数据通过output写到文件
         * @param input
         * @param output
         * @throws IOException
         */
        private static void copyfile1(InputStream input, OutputStream output) {
            byte[] buf = new byte[1024];
            int len;
            try {
                while((len=input.read(buf))!=-1){
                    output.write(buf, 0, len);
                }
            } 
            catch (IOException e) {
                e.printStackTrace();
            }
            finally{
                try {
                    input.close();
                    output.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                
            }
        }
        public static void copyFile(String src, String des, boolean overlay) throws FileNotFoundException{
             copyFile(new File(src), new File(des), overlay);
        }
        /**
         * 
         * @param src 源文件
         * @param des 目标文件
         * @throws FileNotFoundException 
         */
        public static void copyFile(File src, File des, boolean overlay) throws FileNotFoundException {
            FileInputStream fis = null;
            FileOutputStream fos = null;
            BufferedInputStream bis = null;
            BufferedOutputStream bos = null;
            if(src.exists()){
                try {
                    fis = new FileInputStream(src);
                    bis = new BufferedInputStream(fis);
                    boolean canCopy = false;//是否能够写到des
                    if(!des.exists()){
                        des.createNewFile();
                        canCopy = true;
                    }
                    else if(overlay){
                        canCopy = true;
                    }
                    if(canCopy){
                        fos = new FileOutputStream(des);
                        bos = new BufferedOutputStream(fos);
                        copyfile1(bis, bos);
                    }
                    
                } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            else{
                throw new FileNotFoundException(src.getAbsolutePath()+" not found!!!");
            }
            
        }
        
        public static void copyDirectory(String src, String des) throws FileNotFoundException{
            copyDirectory(new File(src), new File(des));
        }
        public static void copyDirectory(File src, File des) throws FileNotFoundException{
            if(src.exists()){
                if(!des.exists()){
                    des.mkdirs();
                }
                File[] fileList = src.listFiles();
                for(File file:fileList){
                    //如果是目录则递归处理
                    if(file.isDirectory()){
                        copyDirectory(file, new File(des.getAbsolutePath()+"/"+file.getName()));
                    }
                    else{
                        //如果是文件，则直接拷贝
                        copyFile(file, new File(des.getAbsolutePath()+"/"+file.getName()), true);
                    }
                }
            }
            else{
                throw new FileNotFoundException(src.getAbsolutePath()+" not found!!!");
            }
        }

![复制代码][copycode.gif]

# 获得当前File对象的绝对路径和名字 #

![复制代码][copycode.gif]

File f = new File("/Users/bemaster/Desktop/in.txt");
    //输出绝对路径， 即/Users/bemaster/Desktop/in.txt
    System.out.println(f.getAbsolutePath());
    //输出父目录路径， 即/Users/bemaster/Desktop/
    System.out.println(f.getParent());
    //输出当然文件或者目录的名字， 即in.txt
    System.out.println(f.getName());

![复制代码][copycode.gif]

# 统计文件或者目录大小 #

获得文件的大小可以使用length()函数。

File f = new File("/Users/bemaster/Desktop/in.txt");
    System.out.println(f.length());

如果对目录使用length()函数，可能会返回错误的结果，所以只好自己写个函数递归统计其包含的文件的大小。

![复制代码][copycode.gif]

private static long getTotalLength1(File file){
            long cnt = 0;
            if(file.isDirectory()){
                File[] filelist = file.listFiles();
                for(File f : filelist){
                    cnt += getTotalLength1(f);
                }
            }
            else{
                cnt += file.length();
            }
            return cnt;
        }
        public static long getTotalLength(String filepath) throws FileNotFoundException{
            return  getTotalLength(new File(filepath));
        }
        public static long getTotalLength(File file) throws FileNotFoundException{
            if(file.exists()){
                return getTotalLength1(file);
            }
            else{
                throw new FileNotFoundException(file.getAbsolutePath()+" not found!!!");
            }
        }

![复制代码][copycode.gif]

# 其它函数 #

File类所提供的函数当前不止这些，还有一些操作，比如获得文件是否可读，可写，可操作；设置文件可读，可写，可操作等等。

# FileUtil工具类 #

下面是自己写的FileUtil工具类。

![复制代码][copycode.gif]

import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    
    
    /**
     * 
     * @author bemaster;
     * @category 文件工具类,包含了基本的文件操作
     * @version 1.0
     * 
     */
    
    public class FileUtil {
        private static final long B = 1;
        private static final long K = B<<10;
        private static final long M = K<<10;
        private static final long G = M<<10;
        private static final long T = G<<10;
        
        /**
         * 
         *删除文件或者目录，如果目录不为空，则递归删除
         * @param filepath 你想删除的文件的路径
         * @throws FileNotFoundException 如果该路径所对应的文件不存在，抛出异常
         * 
         */
        public static void delete(String filepath) throws FileNotFoundException{
            File file = new File(filepath);
            delete(file);
            
        }
        /**
         * 
         *<删除文件或者目录，如果目录不为空，则递归删除
         * @param file filepath 你想删除的文件
         * @throws FileNotFoundException 如果文件不存在，抛出异常
         * 
         */
        public static void delete(File file) throws FileNotFoundException {
            if(file.exists()){
                File []fileList=null;
                //如果是目录，则递归删除该目录下的所有东西
                if(file.isDirectory() && (fileList=file.listFiles()).length!=0){
                    for(File f:fileList)
                        delete(f);
                }
                //现在可以当前目录或者文件了
                file.delete();
            }
            else{
                throw new FileNotFoundException(file.getAbsolutePath() + "is not exists!!!");
            }
        }
        
        /**
         * through output write the byte data which read from input  
         * 将从input处读取的字节数据通过output写到文件
         * @param input
         * @param output
         * @throws IOException
         */
        private static void copyfile1(InputStream input, OutputStream output) {
            byte[] buf = new byte[1024];
            int len;
            try {
                while((len=input.read(buf))!=-1){
                    output.write(buf, 0, len);
                }
            } 
            catch (IOException e) {
                e.printStackTrace();
            }
            finally{
                try {
                    input.close();
                    output.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                
            }
        }
        public static void copyFile(String src, String des, boolean overlay) throws FileNotFoundException{
             copyFile(new File(src), new File(des), overlay);
        }
        /**
         * 
         * @param src 源文件
         * @param des 目标文件
         * @throws FileNotFoundException 
         */
        public static void copyFile(File src, File des, boolean overlay) throws FileNotFoundException {
            FileInputStream fis = null;
            FileOutputStream fos = null;
            BufferedInputStream bis = null;
            BufferedOutputStream bos = null;
            if(src.exists()){
                try {
                    fis = new FileInputStream(src);
                    bis = new BufferedInputStream(fis);
                    boolean canCopy = false;//是否能够写到des
                    if(!des.exists()){
                        des.createNewFile();
                        canCopy = true;
                    }
                    else if(overlay){
                        canCopy = true;
                    }
                    if(canCopy){
                        fos = new FileOutputStream(des);
                        bos = new BufferedOutputStream(fos);
                        copyfile1(bis, bos);
                    }
                    
                } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            else{
                throw new FileNotFoundException(src.getAbsolutePath()+" not found!!!");
            }
            
        }
        
        public static void copyDirectory(String src, String des) throws FileNotFoundException{
            copyDirectory(new File(src), new File(des));
        }
        public static void copyDirectory(File src, File des) throws FileNotFoundException{
            if(src.exists()){
                if(!des.exists()){
                    des.mkdirs();
                }
                File[] fileList = src.listFiles();
                for(File file:fileList){
                    //如果是目录则递归处理
                    if(file.isDirectory()){
                        copyDirectory(file, new File(des.getAbsolutePath()+"/"+file.getName()));
                    }
                    else{
                        //如果是文件，则直接拷贝
                        copyFile(file, new File(des.getAbsolutePath()+"/"+file.getName()), true);
                    }
                }
            }
            else{
                throw new FileNotFoundException(src.getAbsolutePath()+" not found!!!");
            }
        }
        
        public static String toUnits(long length){
            String sizeString = "";
            if(length<0){
                length = 0;
            }
            if(length>=T){
                sizeString = sizeString +  length / T + "T"  ;
                length %= T;
            }
            if(length>=G){
                sizeString = sizeString + length / G + "G" ;
                length %= G;
            }
            if(length>=M){
                sizeString = sizeString + length / M + "M";
                length %= M;
            }
            if(length>=K){
                sizeString = sizeString + length / K+ "K";
                length %= K;
            }
            if(length>=B){
                sizeString = sizeString + length / B+ "B";
                length %= B;
            }
            return sizeString;        
        }
        private static long getTotalLength1(File file){
            long cnt = 0;
            if(file.isDirectory()){
                File[] filelist = file.listFiles();
                for(File f : filelist){
                    cnt += getTotalLength1(f);
                }
            }
            else{
                cnt += file.length();
            }
            return cnt;
        }
        public static long getTotalLength(String filepath) throws FileNotFoundException{
            return  getTotalLength(new File(filepath));
        }
        public static long getTotalLength(File file) throws FileNotFoundException{
            if(file.exists()){
                return getTotalLength1(file);
            }
            else{
                throw new FileNotFoundException(file.getAbsolutePath()+" not found!!!");
            }
        }
    }

![复制代码][copycode.gif]

[copycode.gif]: /images/20220521/702240eaf6e84c0d8b1e7af4f8af95ab.png