• Java之IO流详解（二）——字节流

    一、IO流

    1. IO流概述

    （1）IO：Input读取数据（输入）、Output写数据（输出）。
    （2）流：一种抽象概念，是对数据传输的总称，数据在设备间的传输称为流，流的本质是数据传输，IO流就是用来处理设备间数据传输问题的。
    （3）常见应用：文件的上传、下载、复杂等

    1. IO流的分类

    （1）根据数据流向分类：
    输入流：读数据，将硬盘中的数据读取到内存中；
    输出流：写数据，将程序中的数据写入到硬盘中。

    （2）根据数据类型分类：
    字节流：字节输入流、字节输出流；
    字符流：字符输入流、字符输出流。

    （3）IO流应用场景
    纯文本文件，优先使用字符流；
    图片、视频、音频等二进制文件，优先使用字节流；
    不确定文件类型，优先使用字节流，因为字节流是万能的流。

    二、字节流写入数据

    1. 概述

    1、InputStream：这是个抽象类，是字节输入流的所有类的超类。
    2、OutputStream：这是个抽象类，是字节输出流的所有类的超类。
    3、FileOutputStream：文件输出流，用于将数据写入FIle。
    4、FileOutputStream：创建文件输出流以指定的名称写入文件。

    1. 写入方法
    方法说明
    void write(int b)将指定的字节写入此文件输出流，一次写一个字节数据
    void write(byte[] b)将b.length字节从指定的字节数组写入此文件输出流，一次写一个字节数据
    void write(byte[] b, int off, int len)将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流，一次写一个字节数组的部分数据

    eg:

    public static void main(String[] args) throws IOException {
    FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\test01\\test.txt");
    //void write(int b) 将指定的字节写入此文件输出流，一次写一个字节数据
    fileOutputStream.write(97);
    fileOutputStream.close();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    public static void main(String[] args) throws IOException {
    FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\test01\\test.txt");
    //void write(byte[] b) 将b.length字节从指定的字节数组写入此文件输出流，一次写一个字节数据
    byte[] bytes = {97,98,99,100};
    fileOutputStream.write(bytes);
    fileOutputStream.close();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    public static void main(String[] args) throws IOException {
    FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\test01\\test.txt");
    //void write(byte[] b, int off, int len) 将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流，一次写一个字节数组的部分数据
    byte[] bytes = {97,98,99,100};
    fileOutputStream.write(bytes,1,bytes.length-1);
    fileOutputStream.close();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    public static void main(String[] args) throws IOException {
    FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\test01\\test.txt");
    String str = "chenzeyuhaohaoxiexitiantianxiangshang";
    fileOutputStream.write(str.getBytes());
    fileOutputStream.close();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    1. 写入数据换行、追加写数据

    （1）字节流写入数据换行：

    windows系统的换行符：\r\n
    linux系统的换行符：\n
    mac系统的换行符：\r

    eg：

    //写入数据换行
public static void main(String[] args) throws IOException {
    FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\test01\\test.txt");
    String str = "chenzeyu";
    for (int i=0; i<10; i++){
        fileOutputStream.write(str.getBytes());
        fileOutputStream.write("\r\n".getBytes());
    }
    fileOutputStream.close();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    （2）字节流写入数据通过new FileOutputStream（new File(“C:\Users\Administrator\Desktop\test\test01\test.txt”),true）;表示追加写入数据，如果第二个参数为true，则表示字节流写入文件的末尾。

    eg:

    //追加写数据
public static void main(String[] args) throws IOException {
    FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\test01\\test.txt",true);
    String str = "qizekj";
    for (int i=0; i<10; i++){
        fileOutputStream.write(str.getBytes());
        fileOutputStream.write("\r\n".getBytes());
    }
    fileOutputStream.close();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    1. 字节流写入数据异常的处理
      在异常处理时，是在finally中执行close方法来释放资源。
      eg:
    public static void main(String[] args) {
    FileOutputStream fileOutputStream = null;
    try {
        fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\test01\\test.txt");
        String str = "qizekj";
        for (int i=0; i<10; i++){
            fileOutputStream.write(str.getBytes());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }  finally {
        if(fileOutputStream != null){
            try {
                //释放资源
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    三、字节流读取数据

    1. 概述

    1、FileInputStream：从文件中获取输入字节。
    2、FileInputStream：通过打开与实际文件的连接来创建一个FileInputStream，该文件由路径名name命令。

    1. 常用方法
    方法说明
    int read()从该输入流读取一个字节数据，返回值为 -1 时说明文件读取完毕

    eg:

    public static void main(String[] args) {
    FileInputStream fileInputStream = null;
    try {
        fileInputStream = new FileInputStream("C:\\\\Users\\\\Administrator\\\\Desktop\\\\test\\\\test01\\\\test.txt");
        int read;
        while ((read = fileInputStream.read()) != -1){
            System.out.print((char) read);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(fileInputStream != null){
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    1. 字节流以字节数组的读取数据

    eg:

    public static void main(String[] args) {
    FileInputStream fileInputStream = null;
    try {
        fileInputStream = new FileInputStream("C:\\\\Users\\\\Administrator\\\\Desktop\\\\test\\\\test01\\\\test.txt");
        byte[] bytes = new byte[1024];
        int read;
        while ((read = fileInputStream.read(bytes)) != -1){
            System.out.print(new String(bytes,0, read));
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(fileInputStream != null){
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    四、字节流复制数据

    1. 复制文本数据

    步骤：
    （1）使用FileInputStream把文件内容读到程序内存中；
    （2）使用FileOutputStream把内容写入到另一个文件中。
    eg:

    public static void main(String[] args) {
    FileInputStream fileInputStream = null;
    FileOutputStream fileOutputStream = null;
    try {
        fileInputStream = new FileInputStream("C:\\Users\\Administrator\\Desktop\\test\\test01\\test.txt");
        fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\test02\\test.txt");
        int read;
        while ((read = fileInputStream.read())!= -1){
            fileOutputStream.write(read);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(fileInputStream != null){
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(fileOutputStream != null){
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    1. 字节流复制图片

    eg：

    public static void main(String[] args) {
    FileInputStream fileInputStream = null;
    FileOutputStream fileOutputStream = null;
    try {
        fileInputStream = new FileInputStream("C:\\Users\\Administrator\\Desktop\\test\\test01\\test.jpg");
        fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\test02\\test.jpg");
        byte[] bytes = new byte[1024];
        int read;
        while ((read = fileInputStream.read(bytes))!= -1){
            fileOutputStream.write(bytes,0, read);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(fileInputStream != null){
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(fileOutputStream != null){
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    五、字节缓冲流

    1、使用字节流一个字节一个字节读取或者写入数据，会频繁的发送系统内核调用，所以效率非常低。这时可以使用字节缓冲流，缓冲区是一个内存区域的概念，类似于以“块”的形式写入或者读取数据，减少系统调用频率。
    2、BufferedInputStream(InputStream in)：字节缓冲输入流。
    3、BufferedOutputStream(OutputStream out)：字节缓冲输出流。
    4、字节缓冲流的缓冲区大小默认是8K，即8192字节。

    public static void main(String[] args) {
    //字节缓冲流写数据
    BufferedOutputStream bufferedOutputStream = null;
    try {
        bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("C:\\\\Users\\\\Administrator\\\\Desktop\\\\test\\\\test01\\\\test.txt"));
        bufferedOutputStream.write("hao hao xue xi tian tian xiang shang".getBytes());
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(bufferedOutputStream != null){
            try {
                bufferedOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //字节缓冲流读数据
    BufferedInputStream bufferedInputStream = null;
    try {
        bufferedInputStream = new BufferedInputStream(new FileInputStream("C:\\\\Users\\\\Administrator\\\\Desktop\\\\test\\\\test01\\\\test.txt"));
        int length;
        byte[] bytes = new byte[1024];
        while ((length = bufferedInputStream.read(bytes))!= -1){
            System.out.println(new String(bytes, 0, length));
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(bufferedInputStream != null){
            try {
                bufferedInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 字节缓冲流复制视频
      eg：
    public static void main(String[] args) {
    BufferedInputStream bufferedInputStream = null;
    BufferedOutputStream bufferedOutputStream = null;
    try {
        bufferedInputStream = new BufferedInputStream(new FileInputStream("C:\\Users\\Administrator\\Desktop\\test\\test01\\Wang Wang Team.qlv"));
        bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\test02\\Wang Wang Team.qlv"));
        byte[] bytes = new byte[1024];
        int length;
        while ((length = bufferedInputStream.read(bytes)) != -1){
            bufferedOutputStream.write(bytes,0, length);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(bufferedInputStream != null){
            try {
                bufferedInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(bufferedOutputStream != null){
            try {
                bufferedOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    六、编码与解码、乱码

    • 汉字是GBK编码，则占用2个字节； 汉字是UTF-8编码，则占用3个字节。
    • 当字节流读取存储中文数据时可能会乱码，这时可以用字符流读取存储。 字符流=字节流+编码表。
    • 编码和解码使用的码表一定要一致，否则会导致乱码。
    • 编码表（ASC II）就是生活中的字符和计算机二进制的对照关系表。 如a -> 97。
    • Unicode：世界计算机协会制定通用的编码表，2个字节表示一个字符。
    • UTF-8：Unicode编码表的升级版，汉字基本都是3个字节。
    • GB2312：识别数千个中文。
    • GBK：识别2万多中文，2个字节表示一个字符。
    • GB18030：GBK的升级版。
    • ISO8859-1：欧洲制定的编码表。兼容ASCII。多了一些欧洲的语言，它用1个字节的全部来表示数据。没有未知字符的！。

    编码：

    方法说明
    byte[] getBytes()使用平台的默认字符集将此String编码为byte数组
    byte[] getBytes(String charsetName)使用指定的字符集将此String编码为byte数组

    解码：

    方法说明
    String(byte[] bytes)使用平台的默认字符集解码指定的byte数组，构造一个新的String
    String(byte[] bytes， String charsetName)使用指定的字符集解码指定的byte数组，构造一个新的String

    eg：

    public static void main(String[] args) {
    FileOutputStream fileOutputStream = null;
    FileInputStream fileInputStream = null;
    try {
        String str = "好好学习，天天向上";
        byte[] bytes = str.getBytes("UTF-8");
        fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\test01\\test.txt");
        fileOutputStream.write(bytes);
        fileInputStream = new FileInputStream("C:\\Users\\Administrator\\Desktop\\test\\test01\\test.txt");
        byte[] bytes2 = new byte[1024];
        int length;
        while ((length = fileInputStream.read(bytes2)) != -1){
            System.out.println(new String(bytes2,0, length, "UTF-8"));
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(fileInputStream != null){
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
  • 相关阅读:
    工作中几个问题的思考
    第5期ThreadX视频教程：单片机动态APP加载MPU玩法，隔离应用和系统，APP死机了系统也不会挂（2022-05-15）
    C++使用ffmpeg硬解码
    橘猫去水印小程序源码（可自定义解析接口、后端使用PHP）
    [附源码]java毕业设计电子病历信息管理系统
    Python元组详细教程
    synchronized关键字
    力扣刷题训练(二）
    【随心笔记】假期快过去了，都干了点什么
    【Gradio】Building With Blocks 块中的状 态 + 动态应用程序与渲染装饰器
  • 原文地址：https://blog.csdn.net/qq_36216193/article/details/128058337