文件操作 和 IO - 详解

一，认识文件

1.1 树形结构组织和目录

文件是对于"硬盘"数据的一种抽象，在一台计算机上，有非常多的文件，这些文件是通过 "文件系统" 来进行组织的，本质上就是通过 "目录"(文件夹) 这样的树形结构来组织文件的，画个图理解一下：

有了目录，我们就可以使用目录的层次结构来描述文件所在的位置，即 "路径"。如：D:\Program Files (x86)\编程3\Common\VSPerfCollectionTools\vs2022\1033，在这里还有两个概念：

• 绝对路径：以 C：D：盘符开头的，这种路径就是 "绝对路径"。
• 相对路径：需要指定一个目录作为基准目录，从基准目录出发，到达指定的文件，这里的路径就是 "相对路径"。这些路径往往是以  . (代表当前目录) 或者  .. (代表当前目录的上一级目录) 开头的。

1.2 文件类型

文件主要分为两大类：

1）文本文件：文件中保存的数据都是字符串，保存的内容都是合法字符(计算机存储的数据都是二进制的，能通过字符编码将二进制数据转换成字符的就是合法字符)

2）二进制文件：文件中保存的数据是二进制数据，即不是合法的字符

区分文本文件和二进制文件：将文件直接使用记事本打开，如果是乱码，就是二进制文件，如果不是，就是文本文件。

二，文件操作 - FILE

2.1 属性

E:\01\MSDN 中的 \ 就是 pathSeparator，如果当前的系统是 Windows，\ 或者 / 都可以作为分隔符，如果系统是 Linux 或 Mac ，只能使用 / 作为分隔符，一般建议使用 / 作为分隔符，因为 \ 一般还需要搭配转义字符来使用。

2.2 构造方法

2.3 方法

public class Demo {
    public static void main(String[] args) throws IOException {
        File file = new File("./text.txt");//不要求该文件一定存在
        System.out.println(file.getParent());
        System.out.println(file.getName());
        System.out.println(file.getPath());
        System.out.println(file.getAbsolutePath());
        System.out.println(file.getCanonicalPath());
    }
}

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
 
public class Demo1 {
    public static void main(String[] args) throws IOException {
        File file = new File("d:/text.txt");
        System.out.println(file.exists());//false
        System.out.println(file.isDirectory());//false
        System.out.println(file.isFile());//false
        System.out.println(file.createNewFile());//true
        System.out.println(file.delete());//true
        //file.deleteOnExit();在程序全部执行完之后删除文件
 
        File file1 = new File("d:/");
        String[] ret = file1.list();
        System.out.println(Arrays.toString(ret));
 
        File file2 = new File("d:/aaa/bbb/ccc");
        boolean ans = file2.mkdirs();//能创建多级目录
        //file2.mkdir();只能创建一级目录，如 d:/aaa
        System.out.println(ans);
    }
}

三，文件内容读写 - 数据流

数据流根据文件类型也分成了两种：

1）字节流：对应二进制文件，每次读写的最小单位是 "字节"

2）字符流：对应文本文件，每次读写的最小单位是 "字符"，英文的字符都是一个字节，一个汉字在不同的字符编码中是不同点大小，在 utf8 是 3 个字节，在 unicode 是 2 个字节。（字符流本质上是针对字节流进行的一层封装）

JAVA针对读写两种操作，分别为字节流提供了 InputStream(输入) 和 OutputStream(输出) 类，为字符流提供了 Reader(输入) 和 Writer(输出) 类。这里有一个注意点，如何区分输入和输出，画个图：

 3.1 字符流 - Reader

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
 
public class Demo3 {
    public static void main(String[] args) throws IOException {
        //一次读一个字符
        Reader reader = new FileReader("d:/text.txt");//打开文件
        while(true){
            int n = reader.read();//读取一个字符
            if(n == -1){//返回-1表示文件读取完毕
                break;
            }
            char ch = (char) n;
            System.out.println(n);
        }
        reader.close();
    }
}

但是这么写还是可能会出现文件资源泄露，如果在while循环中抛出异常，下面的close()方法就执行不到了，所以我们可以使用 try...finally..来实现：

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
 
public class Demo3 {
    public static void main(String[] args) throws IOException {
        //一次读多个字符
        Reader reader = new FileReader("d:/text.txt");//打开文件
        try{
            while(true){
                char[] ret = new char[10];
                int n = reader.read(ret);
                if(n == -1) break;
                for (int i = 0; i < n; i++) {
                    System.out.println(ret[i]);
                }
            }
        }finally {
            reader.close();//关闭操作
        }
    }
}

这么写虽然解决了问题，但是不够方便，在这里还有一种写法：

public class Demo3 {
    public static void main(String[] args) throws IOException { 
        //只有实现closeable接口才可以这样写(流对象都可以)
        try(Reader reader = new FileReader("d:/text.txt")){
            while(true){
                char[] ret = new char[10];
                int n = reader.read(ret);
                if(n == -1) break;
                for (int i = 0; i < n; i++) {
                    System.out.println(ret[i]);
                }
            }
        }
    }
}

3.2 字符流 - Writer

注：默认情况下，写入文件会将文件中的原有内容清空。

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
 
public class Demo4 {
    public static void main(String[] args) {
        try(Writer writer = new FileWriter("d:/text.txt")) {
            writer.write("原神，启动！");//写入，先清空再写入
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
 
    /*  在构造方法参数中加一个 true , 就可以直接在文件后面填写，不需要清空
        try(Writer writer1 = new FileWriter("d:/text.txt",true)) {
            writer1.write("原神，启动！");//写入
        } catch (IOException e) {
            throw new RuntimeException(e);
        }*/
    }
}

3.3 字节流 - InputStream

import java.io.*;
 
public class Demo5 {
    public static void main(String[] args) {
        try(InputStream inputStream = new FileInputStream("d:/text.txt")) {
            byte[] buffer = new byte[10];
            while (true){
                int n = inputStream.read(buffer);
                if(n == -1) break;
                for (int i = 0; i < n; i++) {
                    System.out.printf("%x\n",buffer[i]);
                }
            }
        }catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

3.4 字节流 - OutputStream

import java.io.*;
 
public class Demo5 {
    public static void main(String[] args) {
        try(OutputStream outputStream = new FileOutputStream("d:/text.txt",true)){
            String s = "哈哈哈哈";
            outputStream.write(s.getBytes());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

3.5 字节流转字符流

当别人传给你的是一个字节流文件，但是你知道实际数据内容是文本数据时，我们可以通过以下方法来实现转换：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
public class Demo6 {
    public static void main(String[] args) {
        try (InputStream inputStream = new FileInputStream("d:/text.txt")){
            Scanner scanner = new Scanner(inputStream);
            String s = scanner.next();
            System.out.println(s);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

---

 

import java.io.*;
 
public class Demo7 {
    public static void main(String[] args) {
        try(OutputStream outputStream = new FileOutputStream("d:/text.txt")){
            PrintWriter writer = new PrintWriter(outputStream);
            writer.println("fsaf");  
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

 因为 PrintWriter 这个类，在进行写入操作的时候，不一定时直接写入硬盘，而是先把数据写入一个内存中的空间，叫做 "缓冲区"。为什么会出现缓冲区？因为把数据写入内存，是非常快的，而把数据写入硬盘，是非常慢的(比内存慢几千倍甚至更多)，为了提高效率，我们选择降低写硬盘的次数。这样就会出现问题，我们将数据写入 "缓冲区" 后，还没有将缓冲区的数据写入硬盘，进程就结束了，此时数据就丢失了，也就会出现上述图片中的问题。

为了解决该问题，确保数据能完整的写入硬盘，我们需要手动的用 flush() 方法刷新缓冲区：

import java.io.*;
 
public class Demo7 {
    public static void main(String[] args) {
        try(OutputStream outputStream = new FileOutputStream("d:/text.txt")){
            PrintWriter writer = new PrintWriter(outputStream);
            writer.println("fsaf");
            writer.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}