Java字节流与字符流

2022-10-04 09:23:41

九、字节流与字符流

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();
        }
    }    
 
 
 
 
 
 
 
 
 
 
 
 
上一篇：WEKA使用（基础配置+垃圾邮件过滤+聚类分析+关联挖掘）


下一篇：ASP.NET Core WebAPI中的分析工具MiniProfiler