JavaFile类常用方法详解：IO流、重命名、数据操作与对象序列化-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_51578257/article/details/137119381

1. File类常用方法

1.1 获取基本属性

• public String getName() ：获取名称 
• public String getPath() ：获取路径 
• public String getAbsolutePath()：获取绝对路径 
• public File getAbsoluteFile()：获取绝对路径表示的文件 
• public String getParent()：获取上层文件目录路径。若无，返回 null 
• public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。 
• public long lastModified() ：获取最后一次的修改时间，毫秒值

1.2 列出目录的下一级

• public String[] list() ：返回一个 String 数组，表示该 File 目录中的所有子文件或目录。  
• public File[] listFiles() ：返回一个 File 数组，表示该 File 目录中的所有的子文件或目录。

1.3 重命名

• public boolean renameTo(File dest):把文件重命名为指定的文件路径。 
调用该方法的文件必须存在，dest必须不存在，但dest所在目录必须存在，才能成功重命名

1.4 功能判断

• public boolean exists() ：此 File 表示的文件或目录是否实际存在。 
• public boolean isDirectory() ：此 File 表示的是否为目录。 
• public boolean isFile() ：此 File 表示的是否为文件。 
• public boolean canRead() ：判断是否可读 
• public boolean canWrite() ：判断是否可写 
• public boolean isHidden() ：判断是否隐藏

1.5 创建和删除

• public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回 false。 
• public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。
                           如果此文件目录的上层目录不存在，也不创建。 
• public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建。 
• public boolean delete() ：删除文件或者文件夹 删除注意事项：① Java 中的删除不走回收站。
                            ② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。

2. IO流原理及分类

2.1 Java IO原理

Java 程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行，可以看做是一种数据的流动。

I/O 流中的 I/O 是 Input/Output 的缩写， I/O 技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。

– 输入 input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。

– 输出 output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

2.2 流的分类

java.io 包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

• 按数据的流向不同分为：输入流和输出流。

– 输入流：把数据从其他设备上读取到内存中的流。

• 以 InputStream、Reader 结尾

– 输出流：把数据从内存中写出到其他设备上的流。

• 以 OutputStream、Writer 结尾

• 按操作数据单位的不同分为：字节流（8bit）和字符流（16bit）。

– 字节流：以字节为单位，读写数据的流。

• 以 InputStream、OutputStream 结尾

– 字符流：以字符为单位，读写数据的流。

• 以 Reader、Writer 结尾

• 根据 IO 流的角色不同分为：节点流和处理流。

– 节点流：直接从数据源或目的地读写数据

– 处理流：不直接连接到数据源或目的地，而是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。

2.3 流的API

Java 的 IO 流共涉及 40 多个类，实际上非常规则，都是从如下 4 个抽象基类派生的。

（抽象基类）	输入流	输出流
字节流	InputStream	OutputStream
字符流	Reader	Writer

由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

3. FileReader / FileWriter

3.1 读文件


    /**
     * 读hello.txt
     */
    public static void F_Read() {
        String pathName = "demo\\src\\main\\java\\com\\example\\file_IO\\hello.txt";
        FileReader fr = null;

        // 1. 创建File对象
        File file = new File(pathName);

        try {
            // 2. 创建输入型的字符流，用于读取数据
            fr = new FileReader(file);

            // 3. 读取数据

            // // 逐字符读取
            // int date;
            // date = fr.read();
            // while (date != -1) {            // 将Hello,world！逐字符输出
            //     System.out.println((char)date);
            //     date = fr.read();
            // }

            // 以数组批量读取
            /*
             * Hello5
             * , wor5
             * ld!3
             */
            char[] cbuffer = new char[5];
            int len = fr.read(cbuffer);
            while (len != -1) {
                for (int i = 0; i < len; i++) {
                    System.out.print(cbuffer[i]);
                }
                System.out.println(len);
                len = fr.read(cbuffer);  
            }


        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            // 4. 关闭流
            try {
                if (fr != null)  fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

3.2 写文件

    /**
     * 写test1.txt
     * @throws IOException
     */
    public static void F_Write() throws IOException {

        String pathName = "demo\\src\\main\\java\\com\\example\\file_IO\\test1.txt";
        // 1. 创建File对象，指明写出文件名称
        File file = new File(pathName);

        // 2. 创建输出流
        FileWriter fw = new FileWriter(file);  // 覆盖文件
        // FileWriter fw = new FileWriter(file, true);  // 在原有文件添加内容
        
        // 3. 写数据
        fw.write("写操作1");
        fw.write("wwww");

        // 4. 关闭流
        fw.close();

    }

3.3 简单使用

/**
     * 将hello.txt复制到test2.txt
     */
    public static void F_Copy() {

        File src = new File("demo\\src\\main\\java\\com\\example\\file_IO\\hello.txt");
        File dest = new File("demo\\src\\main\\java\\com\\example\\file_IO\\test2.txt");

        FileReader fr = null;
        FileWriter fw = null;

        try {
            fr = new FileReader(src);
            fw = new FileWriter(dest);

            char[] cbuffer = new char[5];
            int len;
            while ((len = fr.read(cbuffer)) != -1) {
                fw.write(cbuffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fr != null) 
                    fr.close();
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }  
    }

4. FileInputStream / FileOutputStream

以复制图像为例，将 qyn.jpg 复制到 qyn_copy.jpg

/**
     * 复制文件
     * 
     */
    public static void main(String[] args) throws IOException {

        // 1. 创建相关File类
        File srcFile = new File("demo\\src\\main\\java\\com\\example\\file_IO\\qyn.jpg");
        File destFile = new File("demo\\src\\main\\java\\com\\example\\file_IO\\qyn_copy.jpg");

        // 2. 创建相关字节流
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos =  new FileOutputStream(destFile);

        // 3. 数据读入和写出
        byte[] buffer = new byte[1024];
        int len;

        while ((len = fis.read(buffer)) != -1) {
            fos.write(buffer, 0, len);
        }

        // 4. 关闭资源
        fis.close();
        fos.close();
        
    }

5. 处理流之一：缓冲流

为了提高数据读写的速度，Java API 提供了带缓冲功能的流类：缓冲流。

缓冲流要“套接”在相应的节点流之上，根据数据操作单位可以把缓冲流分为：

– 字节缓冲流：BufferedInputStream，BufferedOutputStream

– 字符缓冲流：BufferedReader，BufferedWriter

缓冲流的基本原理：在创建流对象时，内部会创建一个缓冲区数组（缺省使用 8192 个字节(8Kb)的缓冲区），通过缓冲区读写，减少系统 IO 次数，从而提高读写的效率。

/**
     * 使用BuffferedInputStream / BufferedOutputStream复制图片
     * @throws IOException 
     */
    public static void test1() throws IOException {
         // 1. 创建相关File类
        File srcFile = new File("demo\\src\\main\\java\\com\\example\\file_IO\\qyn.jpg");
        File destFile = new File("demo\\src\\main\\java\\com\\example\\file_IO\\qyn_copy1.jpg");

        // 2. 创建相关字节流、缓冲流
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos =  new FileOutputStream(destFile);

        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        // 3. 数据读入和写出
        byte[] buffer = new byte[1024];
        int len;

        while ((len = bis.read(buffer)) != -1) {
            bos.write(buffer, 0, len);
        }

        // 4. 关闭资源，先外后内
        // 关闭外层流，
        // 由于外层流的关闭也会自动的对内层的流进行关闭操作，故可以省略内层流的关闭
        bos.close();
        bis.close();
        // // 关闭内层流
        // fis.close();
        // fos.close();
    }

6. 处理流之二：转换流

转换流是字节与字符间的桥梁。

InputStreamReader：转换流 java.io.InputStreamReader，是 Reader 的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。
OutputStreamWriter：转换流 java.io.OutputStreamWriter ，是 Writer 的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

public static void test1() throws IOException {
        // 1. 创建相关File类
        File srcFile = new File("demo\\src\\main\\java\\com\\example\\file_IO\\hello.txt");
        
        // 2. 创建相关流
        FileInputStream fis = new FileInputStream(srcFile);

        // InputStreamReader isr = new InputStreamReader(fis, "gbk");  // 输出：Hello, world! 浣犲ソ锛屼腑鍥斤紒
        InputStreamReader isr = new InputStreamReader(fis, "UTF-8"); // 输出：Hello, world! 你好，中国！

        // 3. 数据读入和写出
        char[] cbuffer = new char[1024];
        int len;

        while ((len = isr.read(cbuffer)) != -1) {
            String str = new String(cbuffer, 0, len);
            System.out.println(str);
        }

        // 4. 关闭资源
        isr.close();
    }

hello.txt的默认字符集为UTF-8，当用gbk字符集去读文件则会出现乱码。

InputStreamReader 和 OutputStreamWriter 搭配使用，可以将文件转换为另外的字符集。

/**
     * 将utf-8文件转换为gbk
     */
    public static void test2() throws IOException {
        // 1. 创建相关File类
        File srcFile = new File("demo\\src\\main\\java\\com\\example\\file_IO\\hello.txt");
        File destFile = new File("demo\\src\\main\\java\\com\\example\\file_IO\\hello_gbk.txt");
        
        // 2. 创建相关流
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

        InputStreamReader isr = new InputStreamReader(fis, "UTF-8"); 
        OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk");

        // 3. 数据读入和写出
        char[] cbuffer = new char[1024];
        int len;

        while ((len = isr.read(cbuffer)) != -1) {
            osw.write(cbuffer, 0, len);
        }

        // 4. 关闭资源
        isr.close();
        osw.close();
    }

7. 处理流之三/四：数据流、对象流

7.1 数据流

数据流：DataOutputStream、DataInputStream

DataOutputStream：允许应用程序将基本数据类型、String 类型的变量写入输出流中
DataInputStream：允许应用程序以与机器无关的方式从底层输入流中读取基本数据类型、String 类型的变量。

数据流 DataInputStream 中的方法：

byte readByte()         short readShort() 
int readInt()           long readLong() 
float readFloat()       double readDouble()  
char readChar()         boolean readBoolean() 
String readUTF()        void readFully(byte[] b)

对象流 DataOutputStream 中的方法：将上述的方法的 read 改为相应的 write 即可。

数据流的弊端：只支持 Java 基本数据类型和字符串的读写，而不支持其它 Java 对象的类型。

7.2 对象流

对象流：ObjectOutputStream、ObjectInputStream

ObjectOutputStream：将 Java 基本数据类型和对象写入字节输出流中。通过在流中使用文件可以实现 Java 各种基本数据类型的数据以及对象的持久存储。
ObjectInputStream：ObjectInputStream 对以前使用 ObjectOutputStream 写出的基本数据类型的数据和对象进行读入操作，保存在内存中。

对象流的强大之处就是可以把 Java 中的对象写入到数据源中，也能把对象从数据源中还原回来。

ObjectOutputStream 中的方法：

public void writeBoolean(boolean val)：写出一个 boolean 值。 
public void writeByte(int val)：写出一个 8 位字节 
public void writeShort(int val)：写出一个 16 位的 short 值 
public void writeChar(int val)：写出一个 16 位的 char 值 
public void writeInt(int val)：写出一个 32 位的 int 值  
public void writeLong(long val)：写出一个 64 位的 long 值 
public void writeFloat(float val)：写出一个 32 位的 float 值。 
public void writeDouble(double val)：写出一个 64 位的 double 值 
public void writeUTF(String str)：将表示长度信息的两个字节写入输出流，后跟字符串 s 中
                                  每个字符的 UTF-8 修改版表示形式。根据字符的值，将字
                                  符串 s 中每个字符转换成一个字节、两个字节或三个字节
                                  的字节组。注意，将 String 作为基本数据写入流中与将
                                  它作为 Object 写入流中明显不同。 如果 s 为 null，
                                  则抛出 NullPointerException。 
public void writeObject(Object obj)：写出一个 obj 对象 
public void close() ：关闭此输出流并释放与此流相关联的任何系统资源

/*
     * 序列化过程：使用 ObjectOutputStream 流将内存中的Java
     * 对象保存在文件中或通过网络传输出去
     */
    public static void test1() throws IOException {

        File file  = new File("demo\\src\\main\\java\\com\\example\\file_IO\\Object.txt");

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));

        oos.writeUTF("序列化过程");
        oos.flush();

        oos.close();
        
    }

    /*
     * 反序列化过程：使用 ObjectInputStream 流将文件中的数据或
     * 网络传输过来的数据还原为内存中的Java对象
     */
    public static void test2() throws IOException {

        File file  = new File("demo\\src\\main\\java\\com\\example\\file_IO\\Object.txt");

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));

        System.out.println(ois.readUTF());

        ois.close();
        
    }