Java字节流与字符流

九、字节流与字符流

9.1 IO的分类

<段落>根据数据的流向分为：输入流和输出流。

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

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

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

                                           

                                          顶级父类表：

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

  9.2字节流输出流

      9.2.1  概述：

                   一切文件数据都是以二进制数字的形式保存，我们要时刻明确，无论使用什么样的流对象，底层传输始终为二进制数据。

      9.2.2 字节输出流的构造方法：  

OutputStream有很多子类，我们从最简单的一个子类开始。

java.io.FileOutputStream类是文件输出流，用于将数据写出到文件。

                   构造方法

public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。notes: 在进行构造的时候，如果父目录不存在，则会报错，在创建时 父目录存在，但是文件不存在，则会帮你创建。

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

notes：

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

                            

 

<wiz_code_mirror>

 

 

 

 

 

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

        // 创建 File 对象

        File file = new File("a.txt");

        // 创建文件输出流对象

        FileOutputStream fos = new FileOutputStream(file);

         // 使用文件 名称创建 输出流对象

        FileOutputStream fos1 = new FileOutputStream("a.txt");

​

        fos.close();

        fos1.close();

    }

 

 

 

        9.2.3字节输出流的基本共性方法：

               java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

• 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) ：将指定的字节输出流。

tipps：

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

                        

 

<wiz_code_mirror>

 

 

 

 

 

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

        // 在 写的时候 是 将原来的删除 然后再去 写

        FileOutputStream fos = new FileOutputStream("fos.txt");

        // 写 数据

        fos.write(97);

        fos.write(98);

        //根据 字节数组 写数据

        byte[] b = {'1','2','3','4'};

        fos.write(b);

        // 将指定 段 数据写入

        // write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节

        fos.write(b,0,2);

        // 关闭

        fos.close();

    }

​

-->输出结果：

        当没有fos.txt文件时，写入ab123412

        有则将其覆盖

 

 

                    tips：

                            1.虽然 参数 为 int 类型 四个字节 但是 只会保留一个字节的信息写出

                            2.流操作完毕后，必须释放系统资源，调用close方法

        数据追加续写： （只需要在 原来的 构造方法 后再加 一个参数 ，true表示 续写，false 表示清空数据）

        每次都会 清空目标文件中的数据，如何保留目标文件中数据，还能继续添加数据

        构造方法：

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

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

        写出换行：

                    回车符  回到一行的开头               换行符另起一行

                    系统中

                    Windows 系统里 换行符合为     

                    Unix系统里 没行结尾只有 换行  即   ;

                    Mac系统里，每行结尾是 回车，即 。从 Mac OS X开始与Linux 统一。 

<wiz_code_mirror>

 

 

 

 

 

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

        // 在 写的时候 是 将原来的删除 然后再去 写

        FileOutputStream fos = new FileOutputStream("fos.txt");

        // 写 数据

        fos.write(97);

        fos.write(98);

        fos.write("
".getBytes());

        //根据 字节数组 写数据

        byte[] b = {'1','2','3','4'};

        fos.write(b);

        // 将指定 段 数据写入

        fos.write(b,0,2);

​

        // 关闭

        fos.close();

    }

结果是：

    ab

    123412

 

 

9.3字节输入流 InputStream

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

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

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

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

tips：

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

        9.3.1 构造方法

                

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

构造方法

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

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

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

<wiz_code_mirror>

 

 

 

 

 

    public static void main(String[] args) throws FileNotFoundException {

        File file = new File("a.txt");

        // 通过构造方法 创建 输入流对象

        FileInputStream fis = new FileInputStream(file);

​

        FileInputStream fis1 = new FileInputStream("a.txt");

    }

 

 

            9.3.2 方法

                    1.读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，当读取到文件末尾的时候 则会返回 -1 。

                    可以根据 -1 来判断是否到达文件末尾：

                    

 

<wiz_code_mirror>

 

 

 

 

 

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

        File file = new File("fos.txt");

        // 通过构造方法 创建 输入流对象

        FileInputStream fis = new FileInputStream(file);

        FileInputStream fis1 = new FileInputStream("fos.txt");

​

        // 提升成 int 类型

        int read = fis.read();

        System.out.println("read = " + read); // 如果不转换成 char 类型 则是97 转成char类型则是 a

        int read1 = fis.read();

        System.out.println("read = " + read1);

        int read2 = fis.read();

        System.out.println("read = " + read2);

        int read3 = fis.read();

        System.out.println("read = " + read3);

        // 读取到文件末尾就返回 -1

​

​

​

        fis.close();

        fis1.close();

    }

 

 

                    2.对循环进行改进 使用while 循环

 

<wiz_code_mirror>

 

 

 

 

 

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

        // 创建文件对象

        File file = new File("fos.txt");

        // 创建 输入流对象

        FileInputStream fis = new FileInputStream(file);

        // 通过while 循环 当 b ！= -1 时 退出

        int b;

        while ((b = fis.read()) != -1) {

            System.out.println("b = " + (char) b);

        }

        // 关闭流对象

        fis.close();

    }

 

 

                    tips：

                            1.虽然读取了一个字节，但是会自动提升 为 int 类型 

                            2. 流操作完毕后，必须释放系统资源， 调用close方法

                

                3.使用字节数组读取 ： read(byte[]  b)， 每次读取b个长度的字节到数组中，返回读取到的有效字节个数 读取到末尾时 返回 -1

<wiz_code_mirror>

 

 

 

 

 

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

        // 使用文件名称创建流对象.

        FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde

        // 定义变量，作为有效个数

        int len ；

        // 定义字节数组，作为装字节数据的容器   

        byte[] b = new byte[2];

        // 循环读取

        while (( len= fis.read(b))!=-1) {

            // 每次读取后,把数组变成字符串打印

            System.out.println(new String(b));

        }

        // 关闭资源

        fis.close();

    }

 

 

                tips：

                        使用数组进行读取，每次读取多个字节，减少系统见4的IO操作的次数，从而 提高了读写的效率，建议开发中使用

                9.3.3视频的复制

                    从已有的文件中读取字节，将该字节写出到另一个文件中

                        

 

<wiz_code_mirror>

 

 

 

 

 

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

        File file = new File("D:\111\shipin.flv");

        // 创建 输入流  将文件读入 到内存中

        FileInputStream fis = new FileInputStream(file);

        // 创建输出流  将数据从内存写入到 文件中

        FileOutputStream fos = new FileOutputStream("D:\2222\flower.flv");

        int len;

        byte[] b = new byte[1024];

        // 循环读取

        while ((len = fis.read(b)) != -1) {

            // 写数据

            fos.write(b,0,len);

        }

        fos.close();

        fis.close();

​

    }

 

 

                        notes：

                                流关闭原则：    先开后关，后开先关

                9.3.4字节缓冲流包装

                                构造方法：

                            public BufferInputStream(InputStream in): 创建一个新的缓冲输入流

                            public BufferOutputStream（OutputStream out）：创建一个新缓冲输出流

<wiz_code_mirror>

 

 

 

 

 

    public static void main(String[] args) throws FileNotFoundException {

        // 创建 字节缓冲输入流

        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));

        // 创建 字节缓冲输出流

        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.txt"));

    }

 

 

                            实现一个复制视频的操作，联系 BufferInputStream 和 BufferOutputStream

                         

 

<wiz_code_mirror>

 

 

 

 

 

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

        // 复制一份视频 用BuffOutputStream

        // 创建一个 输入流对象

        long start = System.currentTimeMillis();

​

        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:/福利赠送.flv"));

        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("s.flv"));

​

        int len;

        byte[] b = new byte[1024*8];

        while ((len = bis.read(b)) != -1){

            bos.write(b);

            bos.flush();

        }

        bos.close();

​

        long end = System.currentTimeMillis();

        System.out.println(end-start);

    }

 

 

 

9.4 字符流

       当使用字节流读取文本文件时，可能会遇到一个小问题。就是遇到中文字符的时候，可能不会显示完整的字符，那是因为一个中午字符 可能 占用多个字节。所有java提供了一些字符流，以字符为单位读写数据，专门用于处理文本文件。

        9.4.1 字符输入流【Reader】

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

                       

• public void close() ：关闭此流并释放与此流相关联的任何系统资源。
  public int read()： 从输入流读取一个字符。
  public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

         9.4.2 FileReader 类

                    java.io.FileReader 类是读取字符文件的类，构造时使用系统默认的字符编码和默认字节缓冲区。

                       tips：

                                    1.字符编码：字节与字符的对应规则。Windows 系统的中午编码默认是GBK 编码表

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

                           构造方法：

                                

FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。

FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。

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

<wiz_code_mirror>

 

 

 

 

 

    public static void main(String[] args) throws FileNotFoundException {

        File file = new File("a.txt");

        // 创建字符输入流对象

        FileReader fr = new FileReader(file);

        // 使用文件名创建流对象

        FileReader fr1 = new FileReader("a.txt");

    }

 

 

                       基本方法：

                                1.read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回 -1 ，循环读取

                                问：为什么 返回值是 int 而不是 byte

 答：因为字节输入流可以操作任意类型的文件，比如图片音频等，这些文件底层都是二进制形式存储的，如果每次读取都返回byte，有可能在读到中间的时候遇到111111111   那么这111111111是byte类型的-1我们程序要是遇到 -1 就会停止不读了，后面的数据就读取不到了 所以选择 int接受，如果111111111会在前面补上24个0凑足4个字节，那么byte类型的-1 就变成int类型的255了 这样就可以保证整个数据读完了，而结束标记的-1就是int类型。

<wiz_code_mirror>

 

 

 

 

 

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

       // a.txt 文件中 有 abc

        File file = new File("a.txt");

        // 创建字符输入流对象

        FileReader fr = new FileReader(file);

         // 定义遍历保存数据

        int b;

        while ((b = fr.read()) != -1) {

            System.out.println("b = " + (char)b);

        }

        fr.close();

    }

​

结果输出：

    a

    b

    c

            /** tips：

                 1.虽然读取了一个字符，但是也会自动提升为int 类型 记得关闭流

                 */

 

 

            2.使用字符数组读取： read(char[]  cbuf)，每次读取b个长度字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回 -1 

 

<wiz_code_mirror>

 

 

 

 

 

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

        FileReader fr = new FileReader("read.txt");

​

        // 定义遍历 保存有效字符个数

        int len;

        // 定义字符数组 作为装字符数据的容器

        char[] buff = new char[2];

        // 进行循环读取

        while ((len=fr.read(buff)) != -1){

            System.out.println("buff = " + new String(buff));

        }

        fr.close();

    }

​

结果：

buff = 我是

buff = 爱J

buff = av

buff = a语

buff = 言语

​

这样会出现 缓冲区 内容 粘包一样的问题

 

 

              优化;

<wiz_code_mirror>

 

 

 

 

 

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

        FileReader fr = new FileReader("read.txt");

​

        // 定义遍历 保存有效字符个数

        int len;

        // 定义字符数组 作为装字符数据的容器

        char[] buff = new char[2];

        // 进行循环读取

        while ((len=fr.read(buff)) != -1){

            System.out.println("buff = " + new String(buff,0,len));

        }

        fr.close();

    }

结果：

buff = 我是

buff = 爱J

buff = av

buff = a语

buff = 言

 

 

                9.4.3 字符输出流【Writer】

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

                        

• public abstract void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
  public abstract void flush() ：刷新此输出流并强制任何缓冲的输出字符被写出。
  public void write(int b) ：写出一个字符。
  `public void write(char[] cbuf)`：将 b.length字符从指定的字符数组写出此输出流。
  public abstract void write(char[] b, int off, int len) ：从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流。
  public void write(String str) ：写出一个字符串。

  1. FielWriter类                  

                                        java.io.FileWriter 类是写出字符到文件的类 ，构造时 使用系统默认的字符编码和默认字节缓冲区。

                                        构造方法：

                                            - FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。   

- FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。

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

<wiz_code_mirror>

 

 

 

 

 

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

        File file = new File("a.txt");

        // 通过文件对象创建 字符输出流对象

        FileWriter fw = new FileWriter(file);

        // 通过文件名字创建一个 字符输出流对象

        FileWriter fw2 = new FileWriter("b.txt");

    }

 

 

                                            基本写出数据方法：write()

                                     write(char[] buff)

                                                write(char[] buff, int off, int len)            与 FileOutputStream

                                               写出字符串

                                     write（String str）和 write(String str , int of ,int len)

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

                                     close：关闭流 ，释放系统资源，关闭前会刷新缓冲区

 

<wiz_code_mirror>

 

 

 

 

 

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

        File file = new File("a.txt");

        // 通过文件对象创建 字符输出流对象

        FileWriter fw = new FileWriter(file);

​

        fw.write(97);

        fw.write('b');

        fw.write('c');

        fw.write(50000); // 中午编码表中50000对应的一个汉字

​

        fw.close();

    }

​

结果：

    abc鱔

    notes：

            1.虽然参数int 类型是四个字节，但是只会保留一个字符 的信息写出。

            2.没有调用close方法，数据只是保存到了缓冲区，并未写出到文件中

            3.即便是调用了 flush 方法 写出了数据，操作的最后还是要 关闭流

 

 

                                                    续写和换行 与FileOutputStream 类似

                        9.4.4 字符缓冲 输入 输出流

<wiz_code_mirror>

 

 

 

 

 

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

        // 创建字符 缓冲 输入 输出流

        BufferedReader br = new BufferedReader(new FileReader("a.txt"));

        BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

​

        // 首先 按照字节进行读取

        int len ;

        char[] b = new char[1024];

        while ((len =  br.read(b)) != -1){

            bw.write(b,0,len);

            bw.flush();

        }

        bw.close();

        br.close();

​

    }

 

 

 

notes：

            字符流，只能操作文本文件，不能操作图片，视频等非文本文件。

    

9.4 IO异常的处理

        9.4.1 JDK 7 之前处理的方式

                        我们一直把异常抛出，而实际开发中并不能这样处理，建议使用try...catch...finally 代码块，处理异常部分

                        

 

<wiz_code_mirror>

 

 

 

 

 

    public static void main(String[] args) {

        // 声明变量

        FileWriter fw = null;

        try {

            //创建流对象

            fw = new FileWriter("fw.txt");

            // 写出数据

            fw.write("我爱JAVA"); //我爱JAVA

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            try {

                if (fw != null) {

                    fw.close();

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

 

 

                9.4.2 JDK 7 的处理方式

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

                            

 

<wiz_code_mirror>

 

 

 

 

 

格式：

    try (创建流对象语句，如果多个,使用';'隔开) {

    // 读写数据

} catch (IOException e) {

    e.printStackTrace();

}

​

演示：

    public static void main(String[] args) {

        // 创建流对象

        try ( FileWriter fw = new FileWriter("fw.txt"); ) {

            // 写出数据

            fw.write("我爱java"); //我爱java

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

 

 

 

                        9.4.3 JDK9 的改动

                                          JDK9中try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close，我们来了解一下格式。  

<wiz_code_mirror>

 

 

 

 

 

改进前的格式：

    // 被final修饰的对象

final Resource resource1 = new Resource("resource1");

// 普通对象

Resource resource2 = new Resource("resource2");

// 引入方式：创建新的变量保存

try (Resource r1 = resource1;

     Resource r2 = resource2) {

     // 使用对象

}

​

改进后的格式：

    // 被final修饰的对象

final Resource resource1 = new Resource("resource1");

// 普通对象

Resource resource2 = new Resource("resource2");

​

// 引入方式：直接引入

try (resource1; resource2) {

     // 使用对象

}

​

演示;'

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

        // 创建流对象

        final  FileReader fr  = new FileReader("in.txt");

        FileWriter fw = new FileWriter("out.txt");

        // 引入到try中

        try (fr; fw) {

            // 定义变量

            int b;

            // 读取数据

            while ((b = fr.read())!=-1) {

                // 写出数据

                fw.write(b);

            }

        } catch (IOException e) {

            e.printStackTrace();

        }

    }