IO（上）

1 输入流和输出流

输入流，数据从源数据源流入程序的过程称为输入流。可以理解为从源数据源读取数据到程序的过程。

输出流，数据从程序流出到目的地的过程称为输出流。可以理解为把数据从程序写入目的地的过程。

数据源一般指提供数据的原始媒介,一般常见有文件、数据库、云端、其他硬件等能提供数据的媒介。

2 流的分类

3 InputStream/OutputStream

InputStream 是所有字节输入流的抽象父类，提供了以下方法：

• read() 读取一个字节
• read(byte[] buf) 读取一定量的字节到缓冲区数组 buf中。

FileInputStream 文件字节输入流，是 InputStream 的一个子类，专门用于从文件中读取字节到程序内存中。

 //需求:从文件读取一个字节
 public static void main(String[] args) {
         File file = new File("d:\\javatest\\a.txt");

         // 【1】创建管道
         FileInputStream in = null;

         try {
             in = new FileInputStream(file);

             // 【2】从管道读取一个字节
             /*
             int t;
             t = in.read();
             t = in.read();
             t = in.read();
             t = in.read();
             */
             // System.out.println(t);

             // 循环读取一个字节
             int t;
             StringBuilder sb = new StringBuilder();
             while( (t=in.read()) != -1 ) {
                 sb.append((char)t);
             }
             System.out.println(sb.toString());
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch(IOException e) {
             e.printStackTrace();
         }

         // 【3】关闭流管道
         try {
             in.close();
         } catch (IOException e) {
             e.printStackTrace();
         }
 }

 //一次读取多个字节
 public static void main(String[] args) {
         File file = new File("d:\\javatest\\a.txt");

         // 【1】创建管道
         FileInputStream in = null;

         try {
             in = new FileInputStream(file);

             // 【2】从管道读取多个字节到缓冲区
             /*
             byte[] buf = new byte[5];
             int len;
             len = in.read(buf);
             len = in.read(buf);
             len = in.read(buf);
             len = in.read(buf);

             for(byte b:buf) {
                 System.out.print((char)b+"\t");
             }
             System.out.println(len);
             */

             // 通过循环读取文件
             byte[] buf = new byte[5];
             int len;
             StringBuilder sb = new StringBuilder();
             while( (len=in.read(buf)) != -1 ) {
                 // 读取的内容是原始二进制流，需要根据编码的字符集解码成对于字符
                 String str = new String(buf,0,len);
                 sb.append(str);
             }
             System.out.println(sb.toString());
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch(IOException e) {
             e.printStackTrace();
         }

         // 【3】关闭流管道
         try {
             in.close();
         } catch (IOException e) {
             e.printStackTrace();
         }
 }

OutputStream 是所有字节输出流的抽象父类，提供了以下方法

• write() 写入一个字节
• write(byte[] buf) 写入一定量的字节到输出流

FileOutputStream 文件字节输出流，专门用于从内存中写入字节到文件中。

 public static void main(String[] args) {
         File file = new File("d:\\javatest\\c.txt");

         FileOutputStream out = null;

         try {
             // 【1】创建输出流管道
             out = new FileOutputStream(file);

             // 【2】写入数据到管道中
             // 一次写入一个字节
             /*
             out.write(97);
             out.write(98);
             out.write(99);
             */

             // 一次写入多个字节
             String str = "hello world";
             // gbk
             /*
             byte[] buf = str.getBytes();
             out.write(buf);
             */

             byte[] buf = str.getBytes("UTF-8");
             out.write(buf);

             System.out.println("写入完成!");

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

         // 【3】关闭流
         try {
             out.close();
         } catch (IOException e) {
             e.printStackTrace();
         }
 }

注意:

1. 字符串写入文件时一定会存在编码问题。
2. 通过字节流写入文件时，向管道写入一个字节，该字节立即写入文件中。

InputStream/OutputStream 用于字节的读写。主要用于读写二进制文件(图片、音频、视频)，较少用于读写文本型文件。对于文本型文件可以使用 Reader/Writer 类。

4 Reader/Writer

Reader 是字符输入流的抽象父类，提供了

• read() 一次读取一个字符
• read(char[] cbuf) 一次读取多个字符到字符缓冲区cbuf，返回长度表示读取的字符个数。

FileReader 文件字符输入流，专门用于读取默认字符编码文本性文件。

 //需求:一次读取一个字符/多个字符到cbuf
 public static void main(String[] args) throws IOException {

         File file = new File("d:\\javatest\\d.txt");

         FileReader reader = new FileReader(file);

         // 【1】一次读取一个字符
         /*
         int c;
         c = reader.read();
         c = reader.read();
         c = reader.read();
         c = reader.read();
         c = reader.read();
         System.out.println((char)c);
         */

         // 【2】一次读取多个字符到cbuf中
         /*
         char[] cbuf = new char[2];
         int len;
         len = reader.read(cbuf);
         len = reader.read(cbuf);
         len = reader.read(cbuf);
         len = reader.read(cbuf);
         System.out.println(Arrays.toString(cbuf));
         System.out.println(len);
         */

         char[] cbuf = new char[2];
         int len;
         StringBuilder sb = new StringBuilder();
         while( (len=reader.read(cbuf)) != -1 ) {
             sb.append(cbuf,0,len);
         }

         System.out.println(sb);
 }

Writer 是字符输出流的抽象父类，提供了

• write()
• write(char[] cbuf)
• write(String str)

FileWriter 文件字符输出流，专门用于写入默认字符编码的文本性文件。为了提高效率，File-Writer内部存在一个字节缓冲区，用于对待写入的字符进行统一编码到字节缓冲区，一定要在关闭流之前，调用flush方法刷新缓冲区，才能完成写入。

 //需求:写入字符到文件中
 public static void main(String[] args) throws IOException {
         File file = new File("d:\\javatest\\f.txt");

         FileWriter writer = new FileWriter(file);

         // 【1】一次写入一个字符
         /*writer.write('中');
         writer.write('国');*/

         // 【2】一次写入多个字符
         /*char[] cbuf = {'h','e','l','l','o','中','国'};
         writer.write(cbuf);*/

         // 【3】一次写入一个字符串
         String str = "hello你好";
         writer.write(str);

         // 刷新字节缓冲区
         writer.flush();

         // 关闭流通道
         writer.close();

         System.out.println("写入完成");
 }

5 转换流

InputStreamReader继承于Reader，是字节流通向字符流的桥梁，可以把字节流按照指定编码 解码 成字符流。

OutputStreamWriter 继承于 Writer，是字符流通向字节流的桥梁，可以把字符流按照指定的编码 编码 成字节流。

• 把一个字符串以utf8编码写入文件

 public class Test {
     public static void main(String[] args) throws IOException {

         String str = "hello中国";
         File file = new File("d:\\javatest\\g.txt");

         // 【1】创建管道
         FileOutputStream out = new FileOutputStream(file);
         OutputStreamWriter writer = new OutputStreamWriter(out, "utf8");

         // 【2】写入管道
         writer.write(str);

         // 【3】刷新缓冲区
         writer.flush();

         // 【4】关闭管道
         out.close();
         writer.close();

         System.out.println("写入完成");
     }
 }

• 读取utf8文件

 public class Test01 {
     public static void main(String[] args) throws IOException {

         File file = new File("d:\\javatest\\g.txt");

         // 【1】建立管道
         FileInputStream in = new FileInputStream(file);
         InputStreamReader reader = new InputStreamReader(in, "UTF-8");

         char[] cbuf = new char[2];
         int len;

         StringBuilder sb = new StringBuilder();
         while( (len=reader.read(cbuf))!=-1 ) {
             sb.append(cbuf, 0, len);
         }
         System.out.println(sb.toString());

     }
 }

Windows 平台默认的 utf8 编码的文本性文件带有 BOM 标识，java 转换流写入的 utf8 文件不带 BOM 标识。所以用 java 读取手动创建的 utf8 文件会出现一点乱码(?hello中国，"?"是 BOM 标识导致的)。

6 BufferedReader/BufferedWriter

BufferedReader 继承于Reader，提供了

• read()
• read(char[] cbuf)
• readLine() 用于读取一行文本，实现对文本的高效读取。

BufferedReader 初始化时需要一个 Reader，本质上 BufferedReader 在 Reader 的基础上增加 readLine() 的功能。

 //需求:读取一首诗
 public static void main(String[] args) throws IOException {

         // 按行读取gbk文本性文件

         File file = new File("d:\\javatest\\i.txt");

         // 【1】创建管道
         FileReader reader = new FileReader(file);
         BufferedReader br = new BufferedReader(reader);

         // 【2】读取一行
         /*
         String line =  br.readLine();
         line =  br.readLine();
         line =  br.readLine();
         line =  br.readLine();
         */

         String line;
         while( (line=br.readLine()) != null) {
             System.out.println(line);
         }
 }

BufferedWriter继承于Writer，提供了

• write()
• write(char[] cbuf)
• write(String str)
• newline() 写入一个行分隔符。

 //需求:以gbk编码写入一首诗到文件
 public static void main(String[] args) throws IOException {

         File file = new File("d:\\javatest\\j.txt");

         // 【1】创建gbk管道
         FileWriter writer = new FileWriter(file);
         BufferedWriter bw = new BufferedWriter(writer);

         // 【2】写入一行
         bw.write("窗前明月光，");
         bw.newLine();

         bw.write("疑似地上霜。");

         // for win
         // bw.write("\r\n");

         // for unix/linux/mac
         // bw.write("\n");

         bw.write("举头望明月,");
         bw.newLine();

         // 【3】flush
         bw.flush();

         // 【4】关闭管道
         bw.close();
         writer.close();
 }

 //需求:以utf8编码高效写入文件
 public static void main(String[] args) throws IOException {

         File file = new File("d:\\javatest\\j-utf8.txt");

         // 【1】创建utf8管道
         FileOutputStream out = new FileOutputStream(file);
         OutputStreamWriter writer = new OutputStreamWriter(out, "UTF-8");
         BufferedWriter bw = new BufferedWriter(writer);

         // 【2】写入一行
         bw.write("窗前明月光，");
         bw.newLine();

         bw.write("疑似地上霜。");

         // for win
         bw.write("\r\n");

         // for unix/linux/mac
         // bw.write("\n");

         bw.write("举头望明月,");
         bw.newLine();

         // 【3】flush
         bw.flush();

         // 【4】关闭管道
         bw.close();
         writer.close();
 }