IO流（01）---字节流、字符流、IO异常处理

IO概述

 什么是IO？

Java中IO的操作主要是靠 java.io 包下面的类的接口来实现的，进行输入、输出操作。输入输出也可以叫做读写数据，输出也可以叫做写入数据。

IO分类

根据数据的流向分为：输入流和输出流

• 输入流：把数据从其他设备上读取到内存当中的流。

• 输出流：把数据从内存当中写入到其他设备上的流。

根据数据的类型分为：字节流和字符流

• 字节流：以字节为单位，读写数据的流。

• 字符流：以字符为单位，读写数据的流。

IO流的顶级父类

	输入流	输出流
字节流	字节输入流 InputStream	字节输出流OutputStream
字符流	字符输入流Reader	字符输出流Writer

字节流

 一切皆为字节

  一切文件数据（文本文档，图片，视频等）在存储时都是以二进制数字的形式保存的，都是一个一个的字节，那么数据在传输的时候也是如此。所有字节流可以传输任意文件的数据。在操作流的时候，我们要明确，无论使用了什么样的流对象，底层传输的始终为二进制数据。

字节输出流[OutputStream]

  java.io.outputSteram 此抽象类是表示输出字节流的所有类的超类,将指定的字节信息写入到目的地。它定义了字节输出流的基本共性的api方法：

• public void close(): 关闭此输出流并释放与此流相关的其他任何系统资源。

• public void flush(): 刷新此输出流并强制任何缓冲的的输出字节信息被写入。

• public void write(byte[] b):将b.length字节从指定的字节数组写入到此输出流中。

• public void write(byte[] b,int off,int len)：从指定的字节数组写入len个字节，从偏移off开始输出中

• public abstract void write(int b):将指定的字节输出到输出流中。

备注：close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileOutputStream类

  java.io.FileOutputstream类是文件字节输出流，用于将数据写入到文件中。

构造方法

• public FileOutputStream(File file):创建一个向指定File 对象表示的文件中写入数据的文件输出流。

• public FileOutputStream(String name):创建文件输出流以指定的的文件名称写入文件中。

当你创建一个流对象时， 必须先传递一个文件路径， 该路径下，如果没有这个文件，会创建该文件，如果有这个文件，会清空这个文件当中的数据。

参数:
File file:目的地是一个文件

String name:目的地是一个文件的路径

构造方法的作用:

1. 创建-个FileOutputStream类对象

2. 会根据构造方法中传递的文件/文件路径(路径上文件不存在)，创建个空的文件 。

3. 会把FiLeOutputStream对象指向创建好的文件。

字节输出流的使用步骤:

1.创建个F ileOutputStream类对象， 构造方法中传 递写入数据的目的地。

2.调用FiLeOutputStream对象中的方法write,把数据写入到文件中

3.释放资源。

示例代码：

  //  1.创建一个FileOutputStream类对象，构造方法中传递写入数据的目的地。
        FileOutputStream fos = new FileOutputStream("day28_IO\a.txt");
        //  2.调用FileOutputStream对象中的方法write，把数据写入到文件中
        fos.write(97);
        //  3.释放资源。
        fos.close();

原理解析：

数据的追加续写

如何在保留目标文件中的数据，还能继续添加新的数据到目标文件中？

• public FileOutputStream(File file,boolean append):创建文件输出流以写入由指定的File对象表示的文件中。

• public FileOutputStream(String name,boolean append):创建文件输出流以指定的名称写入文件中。

这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示的追加数据，false 表示的清空原有数据。
这样的情况下创建输出流对象，就可以指定是否需要在文件的末尾追加。

代码演示：

//1.创建对象
        FileOutputStream fos = new FileOutputStream("day28_IO\c.txt", true);
        //2.调用write()
        fos.write("Java31".getBytes());
        //3.关闭流对象
        fos.close();

写入换行

Windows系统里，换行符号是 。把以指定是否需要追加续写换行。

Linux系统中，换行符号是/n

mac系统里，换行符号是/r

Unix系统里，每行结尾只有换行，即/n

回车符 和换行符

• 回车符：回到一行的开头（）

• 换行符：下一行(newLine)

系统中的换行：

• Windows系统中，每行结尾是 回车+换行。即

• Unix系统中，每行的结尾只有换行。即/n

• Mac系统中，每行的结尾是回车，即 /r

代码示例：

//1.创建对象
        FileOutputStream fos = new FileOutputStream("day28_IO\c.txt", true);
        //实现数据换行
        fos.write("
".getBytes());
        //2.调用write()
        fos.write("Java31".getBytes());
        //3.关闭流对象
        fos.close();

字节输入流【InputStream】

java.io.InputStream 此抽象类是表示字节输入流的所有类的超类。可能读取字节信息到内存中。他定义了字节输入流的基本共性的api方法：

• public void close():关闭此输入流并释放与此流相关的其他的任何系统资源。

• public abstract int read():从输入流中读取数据的下一个字节。

• public int read(byteO[] b):从输入流中读取一些字节数，并将它们存储到字节数组b当中。

备注：close方法当完成流的相关操作后，需要调用此方法关闭输入流，释放系统资源。

FileInputStream类

java.io.FileInputStream 类是文件输入流，从文件中读取字节

构造方法

• FileInputStream(File file):通过打开与实际文件的连接来创建一个FileInputStream, 该文件由文件系统中的File对象file命名。

• FileInputStream(String name):通过打开与实际文件的连接来创建一个FileInputStream,该 文件由文件系统中的路径名name命名。

当你创建一个流对象时， 必须传入一个文件路径。该路经下，如果没有该文件，会抛出 文件找不到异常FileNotFoundException

示例代码：

 // 1. 创建一个FileInputStream类对象，构造方法中绑定要读取的文件
FileInputStream fis = new FileInputStream("day28_IO\c.txt");
// 2. 使用FileInputStream类对象中的方法read(),读取文件中的数据
 int len = 0 ;// 表示记录读取到的字节
    while ( (len = fis.read()) != -1) {
        System.out.print((char)len+"");// Hello
    }
// 3. 释放资源，关闭流对象。
fis.close();

可以使用字节数组来读取数据: read(byte[] b):从输入流中读取多个字节，并且将其存储到缓冲区数组b当中。当
读取到文件的末尾时，返回个-1。

代码演示:

 //1.创建对象
 FileInputStream fis = new FileInputStream("day28_IO\c.txt");
 int  len = 0;// 记录读取到的有效字节个数
 byte[] bytes = new byte[1024];// 2^10 1024b = 1kb
 while ((len = fis.read(bytes)) != -1) {
    // byte[] 转换成String
    // String(byte[] bytes,int offset,int length) 把字节数组的一部分转换成字符串
    //System.out.println(Arrays.toString(bytes));//[B@74a14482
    System.out.println(new String(bytes,0,len));
}

备注：使用数组读取，每次可以读取多个字节，减少了系统间的IO操作次数，从而提高了读取的效率，建议使用。

练习：使用字节流实现图片复制 FileInputStream 和 FileOutputStream

实现从桌面从的psc.jpg图片复制到E:documentsday28_IO目录下。

原理：从已知的文件中读取字节，再把读取到的字节写入到另一个文件中。

public static void main(String[] args) throws IOException {
        // 构建开始时间
        long start = System.currentTimeMillis();
        // 1.创建一个字节输入流对象，构造方法中绑定需要读取的图片路径
        FileInputStream fis = new FileInputStream("C:\Users\admin\Desktop\3.gif");
        // 2.创建一个字节输出流对象，构造方法中绑定需要写入的文件
        FileOutputStream fos = new FileOutputStream("E:\documents\day28_IO\3.gif");
       byte[] bytes = new byte[1024];
        int len = 0;//记录读取到的有效字节个数
        while ((len = fis.read(bytes)) != -1) {
            //4.使用字节输出流对象中的write方法，把读取到字节写入到指定的文件中
            fos.write(bytes,0,len);
        }
        //  5.释放资源。(先开的后关，后开的先关)
        fos.close();
        fis.close();
        // 构建结束的时间
        long end = System.currentTimeMillis();
        System.out.println("复制文件耗费的时间为：" + (end - start) + "ms");
}

备注：流的关闭顺序：先开后关，后开先关。

字符流

当使用字节流读取文件的时候，可能会引发一些问题，如果你遇到了中文字符串的问题，可能不会显示完整的字符。那就是因为一个中文字符占用了多个字节存储。所以Java就提供了一些字符流类，以字符为单位读写数据，专门用于处理文本文档文件。

字符输入流【Reader】

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存当中，它定义了字符输入流的基本共性的api方法:

• public void close():关闭此输入流并且释放与此流相关的其他系统资源。

• public int read():从输入流中读取一个字符。

• public int read(char[] chuf):从输入流中- -次读取多个字符，并将它们存储到字符数组chuf当中。

FileReader类

java.io.FileReader类主要是用于读取字符文件的便捷类。构造方法使用时默认的编码字符集和默认的字节缓冲区。

备注：

1. 字符编码：字节与字符的对应规则。Windows系统中的中文编码默认是GBK编码表，idea中采用UTF-8

2. 字节缓冲区：一个字节数组，用来临时存储字节数据。

构造方法

• FileReader(File file):创建一个新的FileReader对象， 指定需要读取的file对象。

• FileReader(String filename):创建一个新的FileReader对象， 指定需要读取的文件名称。

当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream。

文件字符输入流

  作用：就是把硬盘当中的数据以字符的形式读取到内存当中

完全可以模仿FiLeInputStream

 参数:读取文件的数据源

  String filename: 文件的路径
  File file:一个文件

 FileReader构造方法的作用:

  1.创建一个FileReader对象
  2.会把创建的FileReader对象指向需要读取的文件

字符输入流的使用步骤:完全可以模伤F ileInputStream

1. 创建对象，构造方法中绑定需安读取的文件数据源

2. 使用该对象中的方法read( )来读取文件数据

3. 释放资源，关闭此输入流

示例代码：

// 1.创建对象，构造方法中绑定需要读取的文件数据源
FileReader fr = new FileReader("day28_IO\c.txt");
// 2.使用该对象中的方法read()来读取文件数据
// int read() 读取单个字符并返回
/*int len = fr.read();
        System.out.println((char)len);// 72 H  张*/
int len = 0;// 记录读取的字符 
while ((len = fr.read()) != -1) {
    System.out.print((char)len);
}

使用字符数组读取数据：read(char[] chuf)，每次读取chuf的长度个字符到数组当中，返回读取到有效字符的个数。

当它读取到末尾时，返回-1。

代码示例:

// 1.创建对象，构造方法中绑定需要读取的文件数据源
FileReader fr = new FileReader("day28_IO\c.txt");
char[] chuf = new char[1024];
int len = 0;// 记录的是每次读取的有效的字符个数
//2. 使用该对象中的方法read()来读取文件数据
while ((len = fr.read(chuf)) != -1) {
    // 字符数组转换成字符串  
    System.out.println(new String(chuf,0,len));
}
// 3.释放资源，关闭此输入流。
fr.close();

字符输出流[Writer]

java. io.Writer抽象类是表示用于写入字符流的所有类的超类。将指定的字符信息写入到目的地中。它定义了字符输出流的基本共性api方法：

• void writer（int c）:写入单个字符。

• void write(char] chuf):写入字符数组。

• abstract void write(char[] chuf,int off,int len):写入char数组的一部分，从char数组的起始索引值off开始，len个写入字符串个数。

• void write(String str):写入字符串。

• void write(String str,int ffin len):写入字符串的一部分，从字符串的起始索引off开始，写入len个字符个数。

• void flush():刷新该流的缓冲。

• void close():关闭此流，但是需要先刷新它。

FileWriter类

java.io.FileWrier类是用于写入到文件中。构造方法使用系统默认的字符编码和默认的字节缓冲区。

构造方法

• FileWriter(File file):创建一个新的FileWriter, 指定写入的file对象。

• FilVWriter(String flename): 创建一个新的FileWriter, 指定需要写入的文件的名称。

当你创建一个流对象时， 必须传入一个文件路径，类似于FileOutputStream.

示例代码:

//1.创建个FileWriter对象， 构造方法中绑定 需委写入数据的目的地。
        FileWriter fw = new FileWriter("day28_IO\e.txt");
        // 2.使用fiLeWriter对象中的方法write,把数据写入到内存缓冲区中(字符转换为字节的过程)
        fw.write(107);//K
        //3.使用F ileWriter对象的中的方法fLush.把内存缓冲区中的数据刷新到文件中。
        fw.flush();
        //4.释放资源(会先把内存缓冲区的数据刷新到文件中)
        fw.close();

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写入字符到文件中。但是关闭流对象，是无法继续写入数据到文件中。如果既想写入到文件中，又想继续使用流对象，那么就需要flush方法。

• flush：刷新缓冲区，流对象可以继续使用

• close:先刷新缓冲区，然后会通知系统释放资源，关闭流对象，流对象不可以再使用。

代码演示：

 //1.创建对象
        FileWriter fw = new FileWriter("day_IO\e.txt");
        //2.调用writer方法
        fw.write(97);
        //3.刷新
        fw.flush();
        //刷新之后流可以继续使用
        fw.write(98);
        //4.关闭流对象
        fw.close();
      //close方法之后，流已经关闭了，已经从内存当中消失了，流不能再使用了。
      //如果使用抛出java.io.IOException: Stream closed
        fw.write(99);

续写和换行:操作类似于FileOutputStream

写入字符数组:write(char[] chuf)和write(char[] chuf,int off,int len),每次可以写入一个字符数组的数据，用法类似于FileOutputStream

示例代码：

//1. new
        FileWriter fw = new FileWriter("day28_IO\f.txt");
        //2. write
        //2.1 char[]
        char[] chars = new char[]{'a','b','c','d','e','f'};
        fw.write(chars);// abcdef
        //abstract void write(char[] chuf,int off,in len)：写入字符数组的一部分，从off起始索引开始，写入len个字符个数
        fw.write(chars, 3, 3);// def
        //void write(String str)：写入一个字符串
        fw.write("你好,Java");
        //void write(String str,int off,int len)：写入字符串的一部分，从off起始索引开始，写入len个字符个数
        fw.write("你好,Java",3,4);// Java
        //3. flush
        //fw.flush();
        //4. 关闭
        fw.close();

续写和换行：操作类似于FileOutputStream

 public static void main(String[] args) throws IOException {
        // 1. new
        FileWriter fw = new FileWriter("day28_IO\g.txt", true);
        //2. write
        char[] chars = new char[50];
        //fw.write();
        for (int i = 0; i < 50; i++) {
            chars[i] = (char) (20000+i);
            fw.write(chars[i] + "
");//换行性质
        }
        //3. 刷新
        fw.flush();
        //4. 关闭
        fw.close();
    }

备注:字符流，只能操作文本文件，不能操作图片，视频等份文本文件

  所以当我们单纯的就是想操作文本文件，就使用字符流，其他情况律使用字节流。

IO异常处理

 JDK7新特性

  可以使用try-with-resource语句，该语句确保了每个资源在语句结束时关闭，所谓的资源(resource)是指在程序完成后，必须要关闭的对象。

格式：

```java
try(创建流对象语句，如果多个，请使用";"隔开){
    //可能产生异常的代码
}catch(异常类型 异常变量名){
 //异常处理逻辑   
}
```

实例代码：

```java
public static void main(String[] args) {

        try(FileWriter fw = new FileWriter("a.txt",true);
           FileReader fr =  new FileReader("a.txt");){
            //2.write
            int len = 0;
            while((len = fr.read())!=-1){
                fw.write(len);
            }

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