Java

1. 概述

1. 面试偶尔会问到让你写 文件读写 的面试官

   1. 我搞不懂为啥必须会这玩意
   2. 面试官的意思是, 这玩意只要是个开发就得会
   3. 当然我现在又不是开发

2. 一些概念

   1. 读与写

      1. 参照
         1. 以 进行读写行为的程序 作为参照
      2. 读
         1. 数据从 外部 进入 程序
      3. 写
         1. 数据从 程序 写出到 外部

   2. 流 (stream)

      1. 传统 IO 是和 流(Stream) 做交互
      2. 流是单向的
      3. 流对数据操作的单位, 是 字节
         1. inputstream.read() 一次读入一个字节
         2. outputstream.write(), 有多种参数, 但还是以 字节, 或者 字节数组, 在做读写

   3. Reader / Writer

      1. 但是有时候的读写, 使用 字符 作为单位, 会更加方便
      2. Reader / Writer 也是单向, 根据名字可以得知
      3. Reader / Writer 操作的单位, 是 字符, 这个就不举例子了

   4. 字符编码

      1. 这是个蛋疼的问题
      2. Reader / Writer 只能查看, 无法指定编码
      3. 需要一个 inputstreamReader / outputStreamWriter 来转换
         1. 这个真是蛋疼, 为啥 Reader 和 Writer 就无法直接指定呢
         2. 看了 Reader, BufferedReader, FileReader 都没有
      4. 于是就有了中间类
         1. InputStreamReader
         2. OutputStreamWriter

3. 思路

   1. 只操作字节

      1. inputstream
      2. outputstream

   2. 只操作字符, 并且不需要考虑 字符集 问题

      1. reader
      2. writer

   3. 需要考虑字符集问题

      1. inputstream, inputstreamreader, reader
      2. ouputstream, outputstreamwriter, writer
      3. 后面的示例代码, 就采用这种思路
         1. 看了看是挺烦的

   4. 其他

      1. randomaccessfile

2. 环境

1. 语言
   1. java 1.8

3. 准备

1. 概述

   1. 基本概念

2. 场景

   1. 一次读一行
   2. 读取指定编码

3. 文件(File 对象)

   1. 概述

      1. 读写的目标

   2. 其他

      1. 要读的文件, 需要存在
      2. 通常不要针对同一个文件做读写
      3. 注意目录的 权限

4. 输入

   1. 概述

      1. 就是读
      2. 多层嵌套

   2. FileInputStream

      1. 概述
         1. 文件输入流
         2. 需要 文件对象 来确定输入

   3. InputStreamReader

      1. 概述
         1. 重要参数
            1. 编码

   4. BufferedReader

      1. 概述
         1. 缓存读取效率较高
         2. 可以使用 readline 方法读取一行

5. 输出

   1. 概述

      1. 写文件
      2. 也是多层嵌套

   2. FileOutputStream

      1. 概述
         1. 文件输出流
         2. 需要 文件对象

   3. OutputStreamWriter
      1. 概述
      1. 确定编码

   4. BufferedWriter
      1. 概述
      1. 可以缓存写

4. 示例代码

// 注意: 这里只给出思路, 文件类, 输入输出流可能会遇到异常, 需要 try catch 或者 throws, 并且这些东西, 最好在 finally 里清空和关闭

// 声明变量: 读
// inputPath 是 String 类型的变量, 记录着 输入文件 在文件系统里的位置
File inputFile = new File(inputPath);
FileInputStream fis = new FileInputStream(inputFile);
InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
BufferedReader br = new BufferedReader(fis);
// 下面是简化版本
// BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(inputFile),"UTF-8"));
// 如果不需要调整编码, 也可以这么写
// BufferedReader br = new BufferedReader(new FileReader(inputFile)));

// 声明变量: 写
File outputFile = new File(outputPath);
FileOutputStream fos = new FileOutputStream(outputFile);
OutputStreamWriter osr = new OutputStreamWriter(fos, "UTF-8");
BufferedWriter bw = new BufferedWriter(fos);
// 下面是简化版本
// BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outputFile),"UTF-8"));
// 如果不需要调整编码, 也可以这么写
// BufferedWriter bw = new BufferedWriter(new FileWriter(outputFile)));


//读取数据
//循环取出数据
String str = null;
while ((str = br.readLine()) != null) {
System.out.println(str);
//写入相关文件
bw.write(str);
bw.newLine();
}

//清楚缓存
bw.flush();

//关闭流
br.close();
bw.close();

4. 其他

1. ref

   1. 写的很清晰, 很详细

   https://www.cnblogs.com/ll409546297/p/7197911.html
   

   2. 并发编程网: Java IO 教程, 是原作是老外写的, 他们翻译的不差, 比 TIJ 好懂, 循序渐进.

      http://ifeve.com/java-io/
      

2. 其他的读写场景

   1. 不需要关注编码的读写
   2. 每次读写固定 字符/字节 的场景
   3. randomaccessfile 场景

3. 关于 Java 的 IO

   1. 这种管道套管道的方法, 真的让人难受
   2. 有空可以了解下 python 的 io, 简单的令人窒息

4. 最后的 shutdown 处理

   1. bw 需要一波输出

      1. 可能会有剩余内容

   2. 流的关闭

      1. 只用关闭最顶层的对象即可
         1. 下面的会自己关闭