提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

这篇博客是关于 文件操作和IO 的下半篇的内容，主要介绍的是 文件内容的各种操作 ;

三、文件内容的操作 

关于文件读写的操作，主要分为这几大块：打开文件、关闭文件、读文件、写文件 ;

其中，读写文件 是关键操作 ;

但是，在读写文件之前，必须要打开文件；在使用完毕之后，必须要关闭文件 ;

在 Java中，关于文件读写，提供了几组相关的类（是父类，还有许多其他子类继承）：

1. 第一组：InputStream类、OutputStream类 ——> 字节流（以字节为单位的流，用来操作二进制文件的）
2. 第二组：Reader类、Writer类 ——> 字符流（以字符为单位的流，用来操作文本文件的）

关于 "流"，是计算机中一种常见的概念 ;

比如说，如果想接住 100ml的水 ;

可以一次接 100ml，一次就搞定；可以一次接 50ml，两次就搞定；可以一次接 10ml，十次就搞定 ......

类似于水流，可以随心所欲的控制 读写的数据量 

如：想 读/写 100字节的数据 ~

可以一次 读/写100字节，一次就搞定；可以一次 读/写50字节，两次就搞定；可以一次 读/写10字节，十次就搞定 ......

于是，我们就把这种 读/写 方式，称为 面向流的读/写方式 ;

---

3.1 读文件

3.1.1 使用字节流读文件

我们可以在 Idea 上输入 InputStream类，点击 Ctrl + 左键，便可以发现，InputStream 是一个抽象类，不可以直接 new，需要使用 new InputStream 子类的方式来进行实例化： 

方法：

关于 InputStream类 的常用方法有下面几个：

需要注意的是，要在打开之后 一定记得要关闭文件！！！

—— 需要释放资源（内存、文件描述符表）

—— 如果打开文件之后，忘记关闭，造成的结果非常大的（文件资源泄露，就像是定时炸弹一样，并不是马上就泄露完，这就非常的麻烦了）

一个进程，会使用PCB来描述（此时 只考虑单线程）

PCB 里面有很多属性，文件描述符表 就是其中的一个属性，它可以看作是一个数组（顺序表），其中的每个元素 都对应着当前打开的文件，这个数组的下标 就称为 "文件描述符" ~

每次打开文件，都会在文件描述符表中 占据一个位置，每次关闭文件，都会释放一个位置；由于文件描述符表的长度是存在上限的，所以如果一个线进程一直在打开文件，没有释放文件，此时就会导致 后续进程在打开的时候失败！！！

代码示例：

package file;
 
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
 
public class Demo6 {
    //使用一下 InputStream类
    public static void main(String[] args) throws IOException {
        // 1.打开文件
        //打开文件成功，就得到了 InputStream对象，
        //后续针对文件的操作，都是通过 InputStream 来展开的
        // (就相当于是 空调遥控器 可以操控空调，内存中的 InputStream对象 可以操控硬盘里面的 test2.txt文件)
        //像 inputStream 这一类的 “遥控器”，在计算机中 我们通常称为：句柄(Handler)
        InputStream inputStream = new FileInputStream("./test2.txt");
 
        // 2.读取文件
        while (true) {
            int b = inputStream.read();
            if(b == -1) {
                //此时，文件读完了
                break;
            }
            System.out.println(b);
        }
 
        // 3.关闭文件
        //关闭文件，以释放 内存资源 和 文件描述符表
        inputStream.close();
    }
}

同时，我在 test2.txt 文件下输入了：hello 

运行结果：

---

-- 当然，我们也可以采用其他的 read方法 来读取数据
-- 这里可以把 2.读取文件 的代码改成：
        byte[] b = new byte[1024];
        int len = inputStream.read(b);
        System.out.println(len);
        for (int i = 0; i < len; i++) {
            System.out.println(b[i]);
        }

 此时，运行的结果是：

 3.1.2 使用字符流读文件 

需要注意的是，在上面的 test2.txt 文件中 存储的是英文状态的 "hello"，但是但我们把它改成中文状态的 "你好" 时，那结果可就不一样了 ;

运行结果：

 说明：

当前格式 是 utf-8 的格式编码，它的汉字一般是 三个字节一个汉字 

如果想要直观的获取 中文，那就需要去手动的转换（如下所示）：

-- 这里可以把 2.读取文件 的代码改成：
        byte[] b = new byte[1024];
        int len = inputStream.read(b);
        //把 0到len 这一段数据构成一个字符串，并且指定构造字符集的格式编码 —— utf-8
        String s = new String(b,0,len,"utf-8");
        System.out.println(s);

运行结果：

---

通过字节流，读取文本数据的时候，虽然可以读取到，但是要想真正还原成原始的版本，还是比较麻烦的，需要手动处理;

因此就可以使用 字符流 来解决上述问题（字符流 就相当于已经在底层 已经完成了里面的转换了）;

---

代码示例：

package file;
 
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
 
public class Demo7 {
    //使用字符流读文件
    public static void main(String[] args) throws IOException {
        Reader reader = new FileReader("test2.txt");
        char[] buffer = new char[1024];
        int len = reader.read(buffer);
        for (int i = 0; i < len; i++) {
            System.out.print(buffer[i]);
        }
        //关闭资源
        reader.close();
    }
}

运行结果：

3.1.3 使用Scanner读取文件（推荐）

 字符流来处理文本是比较方便的，但是 这里还有一种更为简单的方法，可以使用 Scanner 来读取文本文件 ;

Scanner scanner = new Scanner(System.in);
//以前我们使用的是这个样子的,可以从键盘上来输入数据
//其中,System.in 中的 in 就是 inputStream
//如果直接把 System.in 换成 inputStream
//需要 InputStream inputStream = new FileInputStream("文本");
//就可以去读自己写的文件

代码示例：

package file;
 
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
 
public class Demo8 {
    //使用 Scanner 来读取文本文件
    public static void main(String[] args) throws IOException {
        InputStream inputStream = new FileInputStream("test2.txt");
        Scanner scanner = new Scanner(inputStream);
        String s = scanner.next();
        System.out.println(s);
        
        inputStream.close();
    }
}

运行结果：

需要注意的是，其实在上述代码中，涉及到了 read操作，这就会引出 IOException异常，此时代码就会无法进行，后面的 关闭文件（close ） 的操作就不会被运行 ;

所以可以使用 try ... catch ... finally ... 的操作来避免的 ;

这里就不做过多演示了 ;

但是，最后就会发现，这个看起来就很啰嗦 ;

所以，就可以改成这个样子了 ：

这样的操作叫做 try with resource（有资源的 try）;

同时，这类写法 会在 try 实现结束之后，自动调用 inputStream 的 close方法（当然，并不是所有的类都可以这样放在try括号里面，要求这个类实现 Closeable接口，才可以这么做）;

这种写法是比较推荐的写法;

 3.2 写文件

字节流：OutputStream / FileOutputStream

字符流：Writer / FileWriter

以及，和 Scanner 相对的 PrintWriter 操作

OutoutStream类 的方法和上面的 InputStream类 的方法差不多，这里就不做过多介绍了，感兴趣的铁铁们可以自己去看看官方文档 ;

3.2.1 使用字节流写文件

package file;
 
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
 
public class Demo10 {
    public static void main(String[] args) {
        try(OutputStream outputStream = new FileOutputStream("test2.txt")) {
            //写文件
            outputStream.write('h');
            outputStream.write('e');
            outputStream.write('l');
            outputStream.write('l');
            outputStream.write('o');
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
}

当我们运行这段代码时，再去查看 text2.txt 文档时，就会发现：

 如果想写一个字符串，那么就可以这样做：

package file;
 
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
 
public class Demo10 {
    public static void main(String[] args) {
        try(OutputStream outputStream = new FileOutputStream("test2.txt")) {
            //写文件
            String s = "hello java";
            outputStream.write(s.getBytes());
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
}

此时，运行程序后，再去看看 test2.txt 文件，就会发现：

注意的是，每一次 写文件 的操作都会清空原有的文件，然后再去重新写 ; 

3.2.2 使用字符流写文件 

package file;
 
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
 
public class Demo11 {
    public static void main(String[] args) {
        try(Writer writer = new FileWriter("test2.txt")) {
            writer.write("hello world");
        }catch (IOException e)  {
            e.printStackTrace();
        }
    }
}

此时，运行程序之后，再次看看 test2.txt 文件，就会发现：

3.2.3 使用PrintWriter写文件

package file;
 
import java.io.*;
 
public class Demo12 {
    public static void main(String[] args) {
        try (OutputStream outputStream = new FileOutputStream("test2.txt")) {
            //此处的 PrintWriter 的用法 和 System.out 有相似之处
            PrintWriter printWriter = new PrintWriter(outputStream);
            printWriter.println("正在看博客的人好帅啊");
            printWriter.flush();
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
}

此时，程序运行结束之后，再来看看 test2.txt 文件：

 

 四、代码案例

---

总结

现在，关于文件操作的有关 内容就结束了，一定要熟练掌握有关文件操作的各个方法和理解其含义；