Java字节流与字符流

时间:2021-10-11 20:59:11

九、字节流与字符流

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): 创建文件输出流以指定的名称写入文件。

        写出换行:
                    \r 回车符  回到一行的开头               \n 换行符另起一行
                    系统中
                    Windows 系统里 换行符合为  \r\n   
                    Unix系统里 没行结尾只有 换行  即  \n;
                    Mac系统里,每行结尾是 回车,即\r 。从 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("\r\n".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();
        }
    }