【文件IO】文件内容操作-阿里云开发者社区

读文件、写文件，都是操作系统提供了 API，在 Java 中也进行了封装，叫“文件流”/“IO流”

Stream

流，形象比喻，水流/气流

水流的特点：我要通过水龙头，接 1000ml 水

直接一口气，把 1000ml 接完

一次接 500ml，分两次接完

一次接 100ml，分十次接完

…

IO 流的特点：我要从文件读取 100 字节文件

直接一口气，把 100 字节读完

一次读 50 字节，分两次读

一次读 10 字节，分十次

…

操作系统本身提供的文件读写 API 就是流式

Java 实现 IO 流，类有很多，主要分为两个大类：

字节流和字符流

字节流：二进制文件使用

读写数据的基本单位，就是字节
一次读的 bit 不可少于 8 个，因为一个字节 8 个 bit，至少得读一个字节

表示字节流的类

InputStream，用来输入的
OutputStream，用来输出的
字符流：文本文件使用

一个字符不确定有几个字节，取决于实际的编码方式（GBK—一个汉字两个字节、UTF 8—一个汉字三个字节，一个字母一个字节）
内部做的工作更多，会自动的查询码表，把二进制数据转换成对应字符

表示字符流的类

Reader，输入
Writer，输出

比如，就像读取某个文件中的前 10 个汉字

使用字符流就可以非常方方便的实现

直接读取 10 个字符

字符流自动判定文件是哪种编码方式，再将字节分割好

再读取对数量字节就得到 10 个汉字了

理解清楚“输入/输出”的方向（人为定义的）

把内存中的数据，放到硬盘上，视为输入还是输出呢？

如果站在内存视角，就是输出

如果站在硬盘视角，就是输入

后面但凡谈到输入输出，都是以 CPU 的视角来谈的，内存离 CPU 比硬盘离 CPU 更近

数据远离 CPU，就是输出，将内存中的数据写到硬盘里

数据靠近 CPU，就是输入，硬盘文件中的数据拿到内存里

上面四个输入输出的类，都是“抽象类”

实际上真正干活的，并非这四个类

另外，Java 中，提供了很多很多类，实现上述的这四个抽象类

因为类太多了，就使得我们对于 IO 流的理解就非常费劲

但虽然种类多，但其实大家的用法都差不多
但凡类的名字是以“Read/Writer”结尾的，就是实现了 Read 和 Writer 的字符流对象
但凡类的名字是以“InputStream/OutputStream”结尾的，就是实现了 InputStream 和 OutputStream 的字节流对象

import java.io.FileInputStream;  
import java.io.IOException;  
import java.io.InputStream;  
  
public class Demo8 {  
    //这个异常是IOException的子类，是其特殊的情况，可以直接写成 IOException    public static void main(String[] args) throws IOException {  
        //因为他是一个抽象类，所以不能直接new  
        //只能new一个实现了它的子类  
        InputStream inputStream = new FileInputStream("./text.txt");  
        //可以指定绝对路径，也可以指定相对路径，也可以指定 File 对象  
        inputStream.close();  
    }
}

FileNotFoundException 这个异常是 IOException 的子类，是他的一种特殊情况，可以就 throws 这个父类异常
抽象类不能直接被new，只能new一个实现了它的子类

在这里还隐藏了一个操作，“打开文件”，针对文件进行读写，务必需要先打开（操作系统的基本要求）

指定路径的时候，可以指定绝对路径，也可以指定相对路径，也可以指定 File 对象
这个代码中，虽然要求文件使用完毕之后要关闭，但是局限于本代码，不写close也行。因为close之后，紧接着就是进程结束了

close 是释放“文件描述符表”里的元素，进程结束，意味着 PCB 就销毁了，PCB 上面的文件描述符表就整个释放了

文件资源泄露

打开文件之后，还需要关闭文件

打开文件，其实是在该进程的文件描述符表中，创建了一个新的表项

进程 => PCB（进程控制块）=> 文件描述表
这个表描述了该进程都需要操作哪些文件
可以认为它是一个数组，数组的每个元素就是一个 struct file 对象（Linux 内核）
每个结构体就描述了对应操作的文件的信息
数组的下标，就称为“文件描述符”

每次打开一个文件，就相当于在数组上占用一个位置，而在系统内核中，文件描述附表数组是固定长度&不可扩容的。除非主动调用 close 关闭文件，此时才会释放空间。如果代码里一直打开，不去关闭，就会使这里的资源越来越少，把数组填满了，后续再打开文件就会打开失败

这样的问题，不容易被发现，泄露不是一瞬间就泄露完耳朵，这是一个持续的过程。整个问题直到所有的资源泄露完毕，这一刻才会集中的爆发出来

import java.io.FileInputStream;  
import java.io.IOException;  
import java.io.InputStream;  
  
public class Demo8 {  
    public static void main(String[] args) {  
        try(InputStream inputStream = new FileInputStream("./text.txt")){  
                    }catch(IOException e){  
            e.printStackTrace();  
        }    
    }
}

在 close 的时候，问了防止因为一些特殊原因代码执行不到 close，有一种特殊的 try 方法——try with sources
这里() 中的创建的资源可以是多个
try{}执行完毕，最终都会自动执行这里的close

不过想在() 里面写，必须是实现了 Closable 接口的类
`

字节流

1. 读文件

在文件打开之后，就需要读文件了

import java.io.FileInputStream;  
import java.io.IOException;  
import java.io.InputStream;  
  
public class Demo8 {  
    public static void main(String[] args) {  
        try(InputStream inputStream = new FileInputStream("./text")){  
            while (true) {  
                int b = inputStream.read();  
                if(b == -1){  
                    //读取完毕  
                    break;  
                }                
                System.out.printf("0x%x\n",b);  
            }        
        }catch(IOException e){  
            e.printStackTrace();  
        }    
    }
}
//运行结果（text文件内容：hello）
0x68
0x65
0x6c
0x6c
0x6f
//（text文件内容：你好）
0xe4
0xbd
0xa0
0xe5
0xa5
0xbd

当读到最后一个字节，就返回 -1
打印字节的时候，一般都用十六进制进行表示，方便随时换算成二进制
hello，可在 ASCII 码表中找到对应单词；“你好”因为是六个字节，所以可以确定是 UTF8 编码方式，就可以在 UTF8 码表中对应打印出的内容拼出“你好”

频繁读取多次硬盘，当前硬盘的 IO 就耗时比较大，希望能减少 IO 的次数

byte[] buffer = new byte[1024];  
int n = inputStream.read(buffer);

这个操作就会把硬盘中读取到的对应的数据，填充到buffer内存的字节数组中，并且尽可能填满（只需要一次IO）

此处是把 buffer 形参当成了“输出型参数”
平时写代码，方法的参数一般是“输入型参数”，使用返回值表示输出结果

虽然是一次读的内容多了，但也比一次读 1 个字节，分很多次读效率高不少
返回的 n 代表实际读到的字节数

这个过程也非常类似于“去食堂打饭”

拿空盘递给阿姨打饭（空 buffer 给 read）
阿姨打满后，再把盘给你（read 把读完的内容装进 buffer）

import java.io.FileInputStream;  
import java.io.IOException;  
import java.io.InputStream;  
  
public class Demo9 {  
    public static void main(String[] args) {  
        try(InputStream inputStream = new FileInputStream("./text")){  
            byte[] buffer = new byte[1024];  
            int n = inputStream.read(buffer);  
            for (int i = 0; i < n; i++) {  
                System.out.printf("0x%x\n",buffer[i]);  
            }        
        }catch (IOException e){  
            e.printStackTrace();  
        }    
    }
}

和 Scanner 结合：

import java.io.FileInputStream;  
import java.io.IOException;  
import java.io.InputStream;  
import java.util.Scanner;  
  
public class Demo14 {  
    public static void main(String[] args) throws IOException{  
        try(InputStream inputStream = new FileInputStream("./text")){  
            Scanner scanner = new Scanner(inputStream);  
            while(scanner.hasNextInt()){  
                System.out.println(scanner.nextInt());  
            }        
        }catch (IOException e){  
            e.printStackTrace();  
        }    
    }
}

这样也可以完成文件内容的读取

2. 写文件

在文件中写入“你好”

import java.io.*;  
  
public class Demo10 {  
    public static void main(String[] args) throws IOException {  
        try(OutputStream outputStream = new FileOutputStream("./text");){  
            outputStream.write(0xe4);  
      outputStream.write(0xbd);  
      outputStream.write(0xa0);  
      outputStream.write(0xe5);  
      outputStream.write(0xa5);  
      outputStream.write(0xbd);
        }catch (IOException e){  
            e.printStackTrace();  
        }    
    }
}

这里是按照一个字节一个字节的方式进行写入的
每次执行写操作的时候，都会先把之前的内容清空

只要使用 OunputStream 打开文件，文件里面的内容就没了
这样的操作，可能就把文件内容搞没了，并且找不回来了

还有一种“追加写”的方式，保持原内容不变，在末尾写入新内容

try(OutputStream outputStream = new FileOutputStream("./text",true);)

在最后加上一个参数 true，代表开启“追加写”的方式

一次把整个字节数组都写入：

import java.io.*;  
  
public class Demo10 {  
    public static void main(String[] args) throws IOException {  
        try(OutputStream outputStream = new FileOutputStream("./text",true);){  
            byte[] buffer = new byte[] {(byte)0xe4,(byte)0xbd,(byte)0xa0,(byte)0xe5,(byte)0xa5,(byte)0xbd};  
            outputStream.write(buffer);  
        }catch (IOException e){  
            e.printStackTrace();  
        }  
    }  
}

InputStream / OutputStream 读写数据就是按照字节来操作的。如果要读写字符的话（中文），此时就绪要靠程序员手动来区分出哪几个字节是一个字符，再确保把这几个字节作为整体来写入

字符流

1. 读文件

为了方便处理字符，引入字符流

一次读一个字符：

import java.io.FileReader;  
import java.io.IOException;  
import java.io.Reader;  
  
public class Demo11 {  
    public static void main(String[] args) throws IOException {  
        try(Reader reader = new FileReader("./text")){  
            while (true) {  
                int c = reader.read();  
                if (c == -1) return;  
                char ch = (char) c;  
                System.out.println(ch);  
            }        }catch (IOException e){  
            e.printStackTrace();  
        }    
    }
}

每次 read 读到的就是一个汉字
最初按照字节来读的时候，是每个汉字三个字节，但在Java中一个char是两个字节，怎么用两个字节表示出了一个汉字？

当使用 char 表示这里的汉字的时候，不再使用 UTF8，而是使用 unicode 编码方式
在 unicode 中，一个汉字就是两个字节

使用字符流读取数据的过程，Java 标准库内部就自动针对数据的编码进行转码了

用字符数组一次读若干字符：

import java.io.FileReader;  
import java.io.IOException;  
import java.io.Reader;  
  
public class Demo12 {  
    public static void main(String[] args) throws IOException {  
        try(Reader reader = new FileReader("./text")){  
            char[] buffer = new char[1024];  
            int n = reader.read(buffer);  
            System.out.println(n);  
            for (int i = 0; i < n; i++) {  
                System.out.println(buffer[i]);  
            }        
        }catch (IOException e){  
            e.printStackTrace();  
        }    
    }
}

2. 写文件

import java.io.FileWriter;  
import java.io.IOException;  
import java.io.Writer;  
import java.nio.channels.WritableByteChannel;  
  
public class Demo13 {  
    public static void main(String[] args) throws IOException {  
        try(Writer writer = new FileWriter("./text")){  
            writer.write("你好世界");  
        }catch (IOException e){  
            e.printStackTrace();  
        }    
    }
}

直接写入一个 String 到文件中

小结：

当前设计的这八个类，虽然数目不少，但用法都很相似

基本流程：打开 —> 读写 —> 关闭

【文件IO】文件内容操作

字节流和字符流

文件资源泄露

字节流

1. 读文件

2. 写文件

字符流

1. 读文件

2. 写文件

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【文件IO】文件内容操作

字节流和字符流

文件资源泄露

字节流

1. 读文件

2. 写文件

字符流

1. 读文件

2. 写文件

热门文章

最新文章

相关电子书