IO文件总结 - 概述以及File类基本用法(一)

IO文件总结 - 概述以及File类基本用法(一)

• 文件概述
• File类基本使用
• 分隔符的使用
• File类常用方法总结
• FilenameFilter、FileFilter过滤器

---

文件概述

• 所有文件，不论是可执行文件、图片文件、视频文件、Word文件、压缩文件、txt文件，都没什么可神秘的，它们都是以0和1的二进制形式保存的；
• 注意文本文件的换行符，在Windows系统中，换行符一般是两个字符"\r\n"，即ASCII码的13('\r')和10('\n')，在Linux系统中，换行符一般是一个字符"\n"；

Java的 I/O 大概可以分成以下几类：

• 磁盘操作：File
• 字节操作：InputStream 和 OutputStream
• 字符操作：Reader 和 Writer
• 对象操作(序列化)：Serializable
• 网络操作：Socket
• 新的输入/输出：NIO

File类中的操作大概可以分为三类：

• 文件元操作
• 文件操作
• 目录操作

---

File类基本使用

基本的构造方法:

public File(String pathname)
public File(String parent, String child)
public File(File parent, String child) 

• pathname表示完整路径，该路径可以是相对路径，也可以是绝对路径。两个参数的构造方法表示父目录的parent和表示孩子的child。
• File中的路径可以是已经存在的，也可以是不存在的。
• 通过new新建一个File对象，不会实际创建一个文件，只是创建一个表示文件或目录的对象，new初始化之后File对象中的路径是不可变的。

基本的方法:

public String getName()   // 返回的就是文件或目录名称，不含路径名。
public boolean isAbsolute()  // 判断File中的路径是否是绝对路径。
public String getPath()   // 返回构造File对象时的完整路径名，包括路径和文件名称。
public String getAbsolutePath() // 返回完整的绝对路径名
public String getCanonicalPath() throws IOException //返回标准的完整路径名，它会去掉路径中的冗余名称如".",".."。
public String getParent() // 返回父目录路径
public File getParentFile() // 返回父目录的File对象，需要注意的是，如果File对象是相对路径，则这些方法可能得不到父目录。
public File getAbsoluteFile()
public File getCanonicalFile() throws IOException

方式使用测试:

public class TestCanocinal {

    public static void main(String[] args) throws IOException {

        File f = new File("../io2/split/in.txt");
        System.out.println(System.getProperty("user.dir")); // 输出用户所在的目录
        System.out.println("path: " + f.getPath());
        System.out.println("absolutePath: " + f.getAbsolutePath());
        System.out.println("canonicalPath: " + f.getCanonicalPath());


        //System.out.println("parent : " + f.getParent());
        //如果file对象是相对路径,使用getParent()会得不到相对应的路径，要先使用下面的两个函数获取

        System.out.println("parent: " + f.getCanonicalFile().getParent());
        System.out.println("parentFile: " + f.getCanonicalFile().getParentFile());
    }
}

使用相对路径和绝对路径构造File对象:

import java.io.File;
/**
 * 测试相对路径和绝对路径   构造File对象
 * 1. 父路径构建 (相对路径的构建)
 * 2. 直接构建(绝对路径的构建)
 *  user.dir (在自己的工作空间)
 */
public class AbsoluteRelativeTest {

    public static void main(String[] args) {
        String parentPath = "/home/zxzxin/Java_Maven/Java8/src/main/java/JavaPrimary/IO/file";
        String name = "in.txt";

        //相对路径的构建 按照父路径
//        File f = new File(parentPath,name);
        File f = new File(new File(parentPath),name);  //这种方式等同于上面的
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getName());


        //绝对路径的直接构建
        File f3 = new File("/home/zxzxin/Java_Maven/Java8/src/main/java/JavaPrimary/IO/file/out.txt");
        System.out.println(f3.getAbsolutePath());
        System.out.println(f3.getName());


        //直接在当前目录下的相对路径的构造 : user.dir (在自己的工作空间输出)
        File f4 = new File("test.txt");
        System.out.println(f4.getPath()); //相对路径  如果是相对路径就输出相对路径
        System.out.println(f4.getAbsolutePath()); //绝对路径
        System.out.println(f4.getName());
    }
}

---

分隔符的使用

File类中有四个静态变量，表示路径分隔符，它们是：

public static final String separator
public static final char separatorChar
public static final String pathSeparator
public static final char pathSeparatorChar

• separator和separatorChar表示文件路径分隔符，在Windows系统中，一般为"\"，Linux系统中一般为"/"。
• pathSeparator和pathSeparatorChar表示多个文件路径中的分隔符，比如环境变量PATH中的分隔符、Java类路径变量classpath中的分隔符，在执行命令时，操作系统会从PATH指定的目录中寻找命令，Java运行时加载class文件时，会从classpath指定的路径中寻找类文件。在Windows系统中，这个分隔符一般为';'，在Linux系统中，这个分隔符一般为':'。

简单测试程序 :

import java.io.File;
/**
 * 测试两个常用的常量
 * 1.路径分割符
 * 2.名称分隔符 \ (windows)   /(linux)
 */
public class SeparatorTest {

    public static void main(String[] args) {
        System.out.println(File.pathSeparator);  //路径分隔符
        System.out.println(File.separator); //分隔符

        //路径的三种表示方法
        //String path = "D:\\github\\ACM"; // windows下
        String path2 =  File.separator + "home" + File.separator + "zxzxin" + File.separator + "C";
        String path3 = "/home/zxzxin/C";

        //File f = new File(path, "test.txt");
        File f2 = new File(path2, "test.txt");
        File f3 = new File(path3, "test.txt");
        //System.out.println(f.getAbsolutePath());
        System.out.println(f2.getAbsolutePath());
        System.out.println(f3.getAbsolutePath());
    }
}

输出结果:

---

File类常用方法总结

/**基本方法**/
public boolean exists()//文件或目录是否存在
public boolean isDirectory() //是否为目录
public boolean isFile() //是否为文件
public long length() //文件长度，字节数
public long lastModified() //最后修改时间，从纪元时开始的毫秒数
public boolean setLastModified(long time) //设置最后修改时间，设置成功返回true，否则返回false

/**安全和权限相关的方法**/
public boolean isHidden() //是否为隐藏文件
public boolean canExecute() //是否可执行
public boolean canRead() //是否可读
public boolean canWrite()  //是否可写
public boolean setReadOnly()  //设置文件为只读文件
public boolean setReadable(boolean readable, boolean ownerOnly) //修改文件读权限
public boolean setReadable(boolean readable)
public boolean setWritable(boolean writable, boolean ownerOnly) 修改文件写权限
public boolean setWritable(boolean writable)
public boolean setExecutable(boolean executable, boolean ownerOnly) //修改文件可执行权限
public boolean setExecutable(boolean executable)

其他一些方法:

• 创建目录: mkdir()、mkdirs()，它们都是创建目录，创建成功返回true，失败返回false。需要注意的是，如果目录已存在，返回值是false。这两个方法的区别在于，如果某一个中间父目录不存在，则mkdir会失败，返回false，而mkdirs则会创建必需的中间父目录。
• 新建一个File对象不会实际创建文件，但使用createNewFile()可以实现，创建成功返回true，否则返回false，新创建的文件内容为空。如果文件已存在，不会创建；
• 临时文件创建(createTempFile())： 临时文件的完整路径名是系统指定的、唯一的，但可以通过参数指定前缀(prefix)、后缀(suffix)和目录(directory)，prefix是必须的，且至少要三个字符，suffix如果为null，则默认为".tmp"，directory如果不指定或指定为null，则使用系统默认目录。
• delete()删除文件或目录，删除成功返回true，否则返回false。如果File是目录且不为空，则delete不会成功，返回false，换句话说，要删除目录，先要删除目录下的所有子目录和文件。deleteOnExit将File对象加入到待删列表，在Java虚拟机正常退出的时候进行实际删除。

上述方法声明如下:

public boolean mkdir() 
public boolean mkdirs()
public boolean createNewFile() throws IOException 
public static File createTempFile(String prefix, String suffix) throws IOException
public static File createTempFile(String prefix, String suffix, File directory) throws IOException
public boolean delete()
public void deleteOnExit()

测试使用:

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

public class FunctionTest {
    /**
     * 1.isFile() isDirectory()  createNewFile() (创建File对象不会创建文件，这个会创建文件) delete()使用
     * 2.分清楚mkdir 和 mkdirs的区别
     */
    public static void main(String[] args) throws IOException, InterruptedException {

        String path = "/home/zxzxin/Java_Maven/Java8/src/main/java/JavaPrimary/IO/file/";

        File f = new File(path + "in.txt");
        if (f.isFile())
            System.out.println("f is a file! ");
        else
            System.out.println("f is not a file !");


        File f2 = new File(path);
        if (f2.isDirectory())
            System.out.println("f2 is a directory!");
        else
            System.out.println("f2 is not a directory!");


        File f4 = new File(f2, "test.java");// f2这个文件目录下面没有666.java
        if(!f4.exists())
            f4.createNewFile();     // 在f2下面创建666.java
        f4.delete();        // 创建出来就删除f4文件


        //必须确保父目录存在
        File f5 = new File(path+"d1");
        f5.mkdir();

        //不必要确保父目录存在, 不论前面的目录是否存在,都创建多个目录
        File f6 = new File(path + "d2/d3/");
        f6.mkdirs();

        //临时文件的创建
        File temp = File.createTempFile("iii", ".temp", new File(path)); //前三个字节长,默认的后缀,以及目录
        Thread.sleep(1000);  // 查看效果
        temp.deleteOnExit();      // 程序退出 就删除
    }
}

---

FilenameFilter、FileFilter过滤器

这些过滤器主要配合下面的方法访问一个目录下的子目录和文件：

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

主要是用来遍历文件以及目录，以及进行过滤操作，看面看几个例子:

• 计算一个目录下的所有文件的大小（包括子目录）；
• 在一个目录下，查找所有给定文件名的文件；
• 删除非空目录下的文件；
• 列出当前目录下的所有后缀为.java的文件；
• 递归打印文件目录；

代码如下:

public class SizeOfDirectoryUseListFiles { //计算一个目录下的所有文件的大小（包括子目录）；

    public static long sizeOfDirectory(final File directly){
        if(directly.isFile())
            return directly.length();
        long size = 0;
        File[] files = directly.listFiles();
        for(File f : files){
            if(f.isDirectory()){
                size += sizeOfDirectory(f);
            }else {
                size += f.length();
            }
        }
        return size;
    }

    public static void main(String[] args){
        File dir = new File("/home/zxzxin/Java_Maven/Java8/src/main/java/JavaPrimary/IO/file");
        System.out.println(sizeOfDirectory(dir));
    }
}

public class FindFile {

    //自动的带上了边界条件
    private static Collection<File> findFile(final File directly, final String fileName){
        List<File>res = new ArrayList<>();
        for(File f : directly.listFiles()){
            if(f.isFile() && f.getName().equals(fileName)){
                res.add(f);
            }else if(f.isDirectory()) {
                res.addAll(findFile(f, fileName));
            }
        }
        return res;
    }

    public static void main(String[] args) throws IOException {
        File dir = new File("/home/zxzxin/Java_Maven/Java8/src/main/java/JavaPrimary/IO/file");
        Collection<File>res = findFile(dir, "test.txt");

        for(File f : res){
            System.out.println(f.getCanonicalPath());
        }
    }
}

//递归清空目录文件的代码, 删除非空目录下的文件；
public class DeleteFile {
    public static void deleteFile(final File file){
        if(file.isFile()){
            file.delete();
        }else if(file.isDirectory()){
            for(File f: file.listFiles()){
                if(f.isFile()){
                    f.delete();
                }else {
                    deleteFile(f);
                }
            }
        }
    }
    public static void main(String[] args){
        File dir = new File("/home/zxzxin/Java_Maven/Java8/src/main/java/JavaPrimary/IO/file/d2/d3");
        deleteFile(dir);
    }
}

import java.io.File;
import java.io.FilenameFilter;
/**
 * 子目录,或者子文件名, 以及文件过滤器的使用
 *  list()   listFiles()  File[] Filters
 *  new FilenameFilter()  按照名字过滤的类　　有一个必须实现的accept()方法
 */
public class ListFileTest {

    public static void main(String[] args) {
        File f = new File("/home/zxzxin/Java_Maven/Java8/src/main/java/JavaPrimary/IO/file");

        if (f.isDirectory()) {
            System.out.println("====子文件-文件名=====");
            String[] subName = f.list();    //获取子文件的名字
            for (String temp : subName) {
                System.out.println(temp);
            }

            System.out.println("====子文件-文件目录=====");
            File[] FNames = f.listFiles();  //获取子文件的目录
            for (File temp : FNames) {
                System.out.println(temp.getPath()); //获取每个文件的名字或者  绝对路径
            }

            //命令设计模式(过滤器)
            System.out.println("====子文件-.java文件=====");
            File[] Filters = f.listFiles(new FilenameFilter() {
                @Override
                public boolean accept(File dir, String name) {
                    return new File(dir, name).isFile() && name.endsWith(".java");//必须是文件且后缀是.java
                }
            });  //获取目录

            for (File temp : Filters) {
                System.out.println(temp.getAbsolutePath()); //获取每个文件的绝对路径
            }
        }

        System.out.println("----------输出它的根目录---------");
        File[] roots = f.listRoots();
        for (File temp : roots) {
            System.out.println(temp.getAbsolutePath());
        }
    }
}

import java.io.File;

/** 递归打印文件目录和文件 **/
public class PrintFileTreeTest {
    public static void printFile(File file, int level) {
        for(int i = 0; i < level; i++) {
            System.out.print("-");
        }
        System.out.println(file.getName());
        if(file.isDirectory()) {
            File[] files = file.listFiles();

            for(File i:files) {
                printFile(i, level+1);
            }
        }
    }
    public static void main(String[] args) {
        File file = new File("/home/zxzxin/Java_Maven/Java8/src/main/java/JavaPrimary/IO");
        printFile(file, 0);
    }
}

效果