Java-File类

import java.io.File;
import java.io.IOException;
/**
 * 文件基本操作
 */
public class FileTest {
    public static void main(String[] args) {
        //根据路径，创建一个文件对象
        File file = new File("E:/printTest.txt");
        //该文件对象提供了对文件判断和操作的方法
        //判断文件是否存在
        if(file.exists()) {
            //文件重命名
            file.renameTo(new File("E:/print.txt"));
            //同分区之间的移动
            file.renameTo(new File("E:/test/print.txt"));
            //判断是否为文件
            Boolean flag = file.isFile(); 
            System.out.println(flag);
            //判断是否为文件夹
            Boolean flag1 = file.isDirectory(); 
            System.out.println(flag1);
            //删除文件
            file.delete(); 
        }else {
            try {
                //如果不存在该文件，则可以根据路径创建文件
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

import java.io.File;
/**
 * 文件常用属性
 */
public class FileTest1 {
    public static void main(String[] args) {
        File file = new File("E:/print.txt");
        boolean exists = file.exists();                    //文件是否存在
        boolean directory = file.isDirectory();         //是否为文件夹
        boolean canRead = file.canRead();                 //文件是否可读
        boolean canWrite = file.canWrite();             //文件是否可写
        String name = file.getName();                    //文件名称
        String path = file.getPath();                    //文件路径
        String absolutePath = file.getAbsolutePath();    //文件的绝对路径
        
        // 文件的父级路径
        // 当创建的file上一级目录为空时返回null   例如:File file = new File("test.txt");
        String parent = file.getParent();
        // 通过以下方式可以获取文件的绝对路径，然后在获取父级路径
        String parent2 = new File(absolutePath).getParent();

        long size = file.length();// byte
        float size1 = (float)file.length()/1000;// KB
        // 文件是否被隐藏  linux中文件以.开头则为隐藏   window中查看文件属性查看是否隐藏
        boolean hidden = file.isHidden(); 
    }
}

import java.io.File;

/**
 * 文件读写属性
 */
public class FileTest2 {
    public static void main(String[] args) {
        File file = new File("E:/print.txt");
        
        file.setWritable(true);//设置可写
        file.setWritable(false);//设置不可写
        
        file.setReadable(true);//设置可读
        file.setReadable(false);//设置不可读
        
        file.setReadOnly();//设置只读
    }
}

import java.io.File;
/**
 * 遍历文件夹
 */
public class FileTest3 {
    public static void main(String[] args) {
        printFiles(new File("E:/test/"),1);
    }
    public static void printFiles(File dir,int tab) {
        if(dir.isDirectory()) {//判断是否为文件夹
            File[] listFiles = dir.listFiles();//获取文件夹中所有的文件
            //遍历获取的所有文件
            for (int i = 0; i < listFiles.length; i++) {
                for (int j = 0; j < tab; j++) {
                    System.out.print("|--");//目录结构的分隔符
                }
                System.out.println(listFiles[i].getName());
                //判断遍历的元素是否为文件夹，如果是则继续调用printFiles()方法
                if(listFiles[i].isDirectory()) {
                    printFiles(listFiles[i],tab+1);
                }
            }
        }
    }
}

import java.io.File;
import java.io.IOException;
import java.nio.file.Path;

/**
 * File类方法介绍
 */
public class FileTest4 {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\test\");
        
        System.out.println(File.separator);//文件的路径分隔符
        
        //路径操作
        System.out.println(file.getName());//如果该路径为文件，则获取文件名称，如果是目录，则获取目录名
        System.out.println(file.getParent());//获取父级路径的字符串
        System.out.println(file.getParentFile());//获取父级路径的File对象
        System.out.println(file.getPath());//获取抽象路径为字符串路径
        System.out.println(file.toURI());//将抽象路径转成uri    file:/E:/test/2/1.txt
        
        System.out.println(file.getAbsolutePath());//获取绝对路径的字符串路径，如果抽象路径不是绝对路径，则默认添加上工程路径
        System.out.println(file.getAbsoluteFile());//获取绝对路径后转成File
        System.out.println(file.getCanonicalPath());//返回规范路径字符串格式
        System.out.println(file.getCanonicalFile());//返回规范路径File对象
        
        //判断
        System.out.println(file.isAbsolute());//判断是否为绝对路径
        System.out.println(file.canRead());//判断是否可读
        System.out.println(file.canWrite());//判断是否可写
        System.out.println(file.canExecute());//是否可执行;
        System.out.println(file.exists());//判断是否存在
        System.out.println(file.isDirectory());//判断是否为目录
        System.out.println(file.isFile());//判断是否为文件
        System.out.println(file.isHidden());//判断是否隐藏
        
        //文件访问权限设置
        file.setReadOnly();//设置文件只读
        file.setReadable(true);//设置文件可读
        file.setReadable(true, true);//第一个是否可读，第二个是否只读
        file.setWritable(true);//设置文件可写
        file.setWritable(true, true);//文件只写，第一个是否可写，第二个是否只写
        file.setExecutable(true);//设置文件可执行
        file.setExecutable(true, true);//第一个是否可执行，第二个文件所属者可执行

        //最后一次修改时间的获取和设置
        System.out.println(file.lastModified());//获取文件最后修改时间
        System.out.println(file.setLastModified(123456L));//设置文件最后一次修改时间
        
        System.out.println(file.length());//如果是文件，则返回文件内容大小字节数，如果是目录则返回0
        
        //创建目录
        file.mkdir();//如果抽象路径是目录，则创建该目录
        file.mkdirs();//创建多级目录，包含父级目录，如果创建失败，可能已经创建了父级目录
        File.createTempFile("aaa", ".temp", file);//指定前缀和后缀，根据File的抽象路径目录，创建临时文件
        
        //创建文件和删除
        System.out.println(file.createNewFile());//文件不存时根据抽象路径创建
        System.out.println(file.delete());//删除目录或者文件，如果是文件，则直接删除，如果是目录，空目录则删除返回true，如果不是空目录，返回false
        file.deleteOnExit();//强制删除，不管目录下是否为空
        
        //获取抽象路径下的目录和文件名称或者所有的抽象路径
        file.list();//返回抽象路径下所有文件名或者目录名的字符串数组(接收参数FilenameFilter)
        file.listFiles();//返回抽象路径下所有文件或者目录的抽象路径File数组(FileFilter或者FilenameFilter)
        
        file.renameTo(new File("2"));
        
        //文件系统操作
        File[] listRoots = file.listRoots();  //获取系统所有根目录 C:  D:  E:
        long totalSpace = file.getTotalSpace();//获取文件所在根目录总容量
        long freeSpace = file.getFreeSpace();//获取文件所在磁盘的可用空间大小
        long usableSpace = file.getUsableSpace();//获取文件所在磁盘已经使用的空间大小
        
        
        int compareTo = file.compareTo(new File("E:\test\"));//比较两个目录，返回0表示路径相同
        boolean equals = file.equals(new File("E:\test\"));//比较两个目录，返回true表示路径相同,否则返回false
        
        file.toString();//返回抽象路径的字符串路径，调用的getPath()方法
        Path path = file.toPath();//抽象路径转成Path对象
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: FileUtil
 * @Description: File工具类
 */
public class FileUtil {
    
    private FileUtil() {}
    private static File file = null;
    private static List<File> fList = new ArrayList<File>();
    private static List<String> sList = new ArrayList<String>();
    private static List<byte[]> bList = new ArrayList<byte[]>();
    
    private static InputStream in = null;
    private static OutputStream out = null;
    
    private static BufferedReader br = null;
    private static BufferedWriter bw = null;
    
    @SuppressWarnings("unused")
    private static int num = -1;
    private static String str = null;
    
    /**
     * @Title: getFile
     * @Description: 根据文件路径，判断该文件是否存在，如果不存在则创建，并返回该file对象
     * @param pathName
     * @return File  返回类型
     * @throws
     */
    public static File getFile(String pathname) {
        file = new File(pathname);
        try {
            if(!file.exists()) {
                file.createNewFile();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return file;
    }
    
    /**
     * @Title: getAllFile
     * @Description: 获取目录下所有的文件,1.传入文件路径，返回该文件的File实例。2.如果传入目录路径，返回目录下所有文件实例
     * @param pathname
     * @return List<File>
     * @throws
     */
    public static List<File> getAllFile(String pathname) {
        file = new File(pathname);
        
        if(file.isDirectory()) {
            File[] files = file.listFiles();
            for (int i = 0; i < files.length; i++) {
                if(files[i].isFile()) {//如果是文件
                    fList.add(files[i]);
                }else {
                    getAllFile(files[i].getPath());
                }
            }
        }else {
            fList.add(file);
        }
        return fList;
    }
    
    
    
    
    
    /**
     * @Title: readFileByInputStream
     * @Description: 根据文件路径，读取文件内容，并返回所读取的所有内容。字节流读取，每次读取1204个字节
     * @param frompathname
     * @return List<byte[]>  返回类型
     * @throws
     */
    public static List<byte[]> readFileByInputStream(String frompathname) {
        try {
            in = new FileInputStream(FileUtil.getFile(frompathname));
            byte[] b = new byte[1024];
            while((num = in.read(b)) != -1) {
                bList.add(b);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(in!=null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return bList;
    }
    
    /**
     * @Title: readFileByInputStream
     * @Description: 根据File对象，读取文件内容，并返回所读取的所有内容。字节流读取，每次读取1204个字节,如果file不是文件，则返回null
     * @param frompathname
     * @return List<byte[]>  返回类型
     * @throws
     */
    public static List<byte[]> readFileByInputStream(File file) {
        try {
            if(file!=null && file.isFile()) {
                in = new FileInputStream(file);
                byte[] b = new byte[1024];
                while((num = in.read(b)) != -1) {
                    bList.add(b);
                }
            }else {
                return null;
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(in!=null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return bList;
    }
    
    
    /**
     * @Title: readFileByInputStreamReader
     * @Description: 根据文件路径，读取全部内容,指定编码，字节转字符然后使用缓冲流
     * @param pathname
     * @return
     * @return List<byte[]> 
     * @throws
     */
    public static List<String> readFileByInputStreamReader(String frompathname,String encoding) {
        try {
            br = new BufferedReader(new InputStreamReader(new FileInputStream(FileUtil.getFile(frompathname)),encoding));
            while((str = br.readLine()) != null) {
                sList.add(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(in!=null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return sList;
    }
    
    /**
     * @Title: readFileByInputStreamReader
     * @Description: 根据File对象，读取全部内容,指定编码，字节转字符然后使用缓冲流
     * @param pathname
     * @return
     * @return List<byte[]> 
     * @throws
     */
    public static List<String> readFileByInputStreamReader(File file,String encoding) {
        try {
            if(file!=null && file.isFile()) {
                br = new BufferedReader(new InputStreamReader(new FileInputStream(file),encoding));
                while((str = br.readLine()) != null) {
                    sList.add(str);
                }
            }else {
                return null;
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(in!=null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return sList;
    }
    
    
    /**
     * @Title: readFileByBufferedReader
     * @Description: 根据文件路径，读取全部内容,字符流加缓冲流
     * @param pathname
     * @return
     * @return List<byte[]> 
     * @throws
     */
    public static List<String> readFileByBufferedReader(String frompathname) {
        try {
            br = new BufferedReader(new FileReader(FileUtil.getFile(frompathname)));
            while((str = br.readLine()) != null) {
                sList.add(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(in!=null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return sList;
    }
    
    /**
     * @Title: readFileByBufferedReader
     * @Description: 根据File对象，读取全部内容,字符流加缓冲流
     * @param pathname
     * @return List<byte[]> 
     * @throws
     */
    public static List<String> readFileByBufferedReader(File file) {
        try {
            if(file!=null && file.isFile()) {
                br = new BufferedReader(new FileReader(file));
                while((str = br.readLine()) != null) {
                    sList.add(str);
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(in!=null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return sList;
    }
    
    
    
    /**
     * @Title: writeFileByOutputStream
     * @Description: 写内容到文件，字节流
     * @param list
     * @param topathname
     * @return void  返回类型
     * @throws
     */
    public static void writeFileByOutputStream(List<byte[]> list,String topathname) {
        try {
            out = new FileOutputStream(FileUtil.getFile(topathname));
            for (byte[] b : list) {
                out.write(b);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(out!=null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    /**
     * @Title: writeFileByOutputStream
     * @Description: 将指定内容写入到File，字节流
     * @param list
     * @param topathname
     * @return void  返回类型
     * @throws
     */
    public static void writeFileByOutputStream(List<byte[]> list,File file) {//每次需要循环多次写，需优化
        try {
            if(file!=null && file.isFile()) {
                out = new FileOutputStream(file);
                for (byte[] b : list) {  
                    out.write(b);
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(out!=null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    
    /**
     * @Title: writeFileByBufferWrite
     * @Description: 写出内容到文件，不能指定编码，字符流
     * @param sList
     * @param topathname
     * @return void  返回类型
     * @throws
     */
    public static void writeFileByBufferWrite(List<String> sList,String topathname) {
        try {
            bw = new BufferedWriter(new FileWriter(FileUtil.getFile(topathname)));
            for (String str : sList) {
                bw.write(str);
            }
            bw.flush();//将流中的数据刷新出去
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(out!=null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    /**
     * @Title: writeFileByBufferWrite
     * @Description: 写出内容到文件，字符流
     * @param sList
     * @param topathname
     * @return void  返回类型
     * @throws
     */
    public static void writeFileByBufferWrite(List<String> sList,File file) {
        try {
            if(file!=null && file.isFile()) {
                bw = new BufferedWriter(new FileWriter(file));
                for (String str : sList) {
                    bw.write(str);
                }
                bw.flush();//将流中的数据刷新出去
            }else {
                throw new Exception("写入失败，检查file");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(out!=null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    
    /**
     * @Title: writeFileByOutputStreamWriter
     * @Description: 写出内容到文件，可以指定编码格式，字符流
     * @param sList
     * @param topathname
     * @return void  返回类型
     * @throws
     */
    public static void writeFileByOutputStreamWriter(List<String> sList,String topathname) {
        try {
            bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(FileUtil.getFile(topathname)),"GBK"));
            for (String str : sList) {
                bw.write(str);
            }
            bw.flush();//将流中的数据刷新出去
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(out!=null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    /**
     * @Title: writeFileByOutputStreamWriter
     * @Description: 写出内容到文件，指定编码格式，字节转字符，加缓冲流
     * @param sList
     * @param topathname
     * @return void  返回类型
     * @throws
     */
    public static void writeFileByOutputStreamWriter(List<String> sList,File file,String encoding) {
        try {
            if(file!=null && file.isFile()){
                bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file),encoding));
                for (String str : sList) {
                    bw.write(str);
                }
                bw.flush();//将流中的数据刷新出去
            }else {
                throw new Exception("写入失败，检查file");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(out!=null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}