IO流—字节流

矫情吗；* 2024-03-08 07:06 120阅读 0赞

### 1、IO流-字节流 ###

#### 1.1 IO流的概述 ####

IO流的作用：就是可以对文件或者网络中的数据进行读、写操作。如下图所示：

把数据从磁盘、网络中读取到程序中来，用到的是输入流。

把程序中的数据写入磁盘、网络中，用到的是输出流。

**简单记：输入流（读数据）、输出流（写数据）。**

![0445e53c400e4fcf94632363f5dcaf79.png][]

IO流在Java中有很多种，不同的流来干不同的事情。Java把各种流用不同的类来表示，这些六的继承体系下图所示：

> IO流分为两大派系：
> 
> 1.字节流：字节流又分为字节输入流、字节输出流。
> 
> 2.字符流：字符流又分为字符输入流、字符输出流。

![8056cdead9fb402fa3b48bf1630d6ad3.png][]

#### 1.2 FileInputStream读取一个字节 ####

IO流中的字节输入流用InputStream表示，但是InputStream是抽象类，不能直接new对象，所以我们用它的子类，叫FileInputStream。

![8c56fc2a3d3f4961866c739485aee4ec.png][]

需要用到的方法如下图所示：有构造方法、成员方法。

![97bccf8448d3479091bc796d2453d5bf.png][]

使用FileInputStream读取文件中的字节数据，步骤如下：

> 第一步：创建FileInputStream文件字节输入流管道，与源文件接通。
> 
> 第二步：调用read()方法开始读取文件的字节数据。
> 
> 第三步：调用close()方法释放资源。

代码如下：

/**
     * 目标：掌握文件字节输入流，每次读取一个字节。
     */
    public class FileInputStreamTest1 {
        public static void main(String[] args) throws Exception {
            // 1、创建文件字节输入流管道，与源文件接通。
            InputStream is = new FileInputStream(("file-io-app\\src\\test01.txt"));
    
            // 2、开始读取文件的字节数据。
            // public int read():每次读取一个字节返回，如果没有数据了，返回-1.
            int b; // 用于记住读取的字节。
            while ((b = is.read()) != -1){
                System.out.print((char) b);
            }
            
            //3、流使用完毕之后，必须关闭！释放系统资源！
            is.close();
        }
    }

**注意事项**：由于一个中文在UTF-8编码方案中是占3个字节，采用一次读取一个字节的方式，读一个字节就相当于读了1/3个汉字，此时这个字节转换为字符，是会有乱码的。

#### 1.3 FileInputStream读取多个字节 ####

上面FileInputStream调用read()方法，可以一次读取一个字节。但是这种读取方式效率太慢了，为了提高效率，我们可以使用另一个read(byte\[\] bytes)的重载方法，可以一次读取多个字节，至于一次读多少个字节，就在于你传输的数组有多大。

使用FileInputStream一次读取多个字节的步骤如下：

> 第一步：创建FileInputStream文件字节输入流管道，与源文件接通。
> 
> 第二步：调用read(byte\[\] bytes)方法开始读取文件的字节数据。
> 
> 第三步：调用close()方法释放资源。

代码如下：

/**
     * 目标：掌握使用FileInputStream每次读取多个字节。
     */
    public class FileInputStreamTest2 {
        public static void main(String[] args) throws Exception {
            // 1、创建一个字节输入流对象代表字节输入流管道与源文件接通。
            InputStream is = new FileInputStream("file-io-app\\src\\test02.txt");
    
            // 2、开始读取文件中的字节数据：每次读取多个字节。
            //  public int read(byte b[]) throws IOException
            //  每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1.
    
            // 3、使用循环改造。
            byte[] buffer = new byte[3];
            int len; // 记住每次读取了多少个字节。  abc 66
            while ((len = is.read(buffer)) != -1){
                // 注意：读取多少，倒出多少。
                String rs = new String(buffer, 0 , len);
                System.out.print(rs);
            }
            // 性能得到了明显的提升！！
            // 这种方案也不能避免读取汉字输出乱码的问题！！
    
            is.close(); // 关闭流
        }
    }

需要注意的是：**read(byte\[\] bytes)它的返回值，表示i当前这一次读取的字节个数。**

假设有一个a.txt文件如下：

> abcde

每次读取过程如下：

> 也就是说，并不是每次读取的时候都把数组装满，比如数组是 byte\[\] bytes = new byte\[3\];
> 
> 第一次调用read(bytes)读取了3个字节（分别是98，98，99），并且往数组中存，此时返回值就是3。
> 
> 第二次调用read(bytes)读取了2个字节（分别是99，100），并往数组中存，此时返回值是2
> 
> 第三次调用read(bytes)读取，文件中后面已经没有数据了，此时返回值为-1

**注意事项**：采用一次读取多个字节的形式，也是可能乱码的。因为也有可能读取到半个汉字的情况。

#### 1.4 FileInputStream读取全部字节 ####

前面讲的，不管是一次读取一个字节，还是一次读取多个字节，都有可能乱码。那怎样才能不出现乱码呢？

我们可以一次性读取文件中的全部字节，然后把全部字节转换为一个字符串，就不会有乱码了。

![05c2fde4a7d44ad7b4822bbe201d6db4.png][]

// 1、一次性读取完文件的全部字节到一个字节数组中去。
    // 创建一个字节输入流管道与源文件接通
    InputStream is = new FileInputStream("file-io-app\\src\\test03.txt");
    
    // 2、准备一个字节数组，大小与文件的大小正好一样大。
    File f = new File("file-io-app\\src\\test03.txt");
    long size = f.length();
    byte[] buffer = new byte[(int) size];
    
    int len = is.read(buffer);
    System.out.println(new String(buffer));
    
    //3、关闭流
    is.close();

![fbb96478812e44ecaccf9b5822d499e0.png][]

// 1、一次性读取完文件的全部字节到一个字节数组中去。
    // 创建一个字节输入流管道与源文件接通
    InputStream is = new FileInputStream("file-io-app\\src\\test03.txt");
    
    //2、调用方法读取所有字节，返回一个存储所有字节的字节数组。
    byte[] buffer = is.readAllBytes();
    System.out.println(new String(buffer));
    
    //3、关闭流
    is.close();

**注意事项**：**一次性读取所有字节，虽然可以解决乱码问题，但是文件不能过大，如果文件过大，可能导致内存溢出。**

#### 1.5 FileOutputSteam写字节 ####

往文件中写数据，需要用到OutputStream下面的一个子类FileOutputStream，写输入的流程如图所示：

![965750db0b0f40298ee3d74cf6f59fec.png][]

使用FileOutputStream往文件中写数据的步骤如下：

> 第一步：创建FileOutputStream文件字节输出流管道，与目标文件接通。
> 
> 第二步：调用write()方法往文件中写数据。
> 
> 第三步：调用close()方法释放资源。

代码如下：

/**
     * 目标：掌握文件字节输出流FileOutputStream的使用。
     */
    public class FileOutputStreamTest4 {
        public static void main(String[] args) throws Exception {
            // 1、创建一个字节输出流管道与目标文件接通。
            // 覆盖管道：覆盖之前的数据
    //        OutputStream os =
    //                new FileOutputStream("file-io-app/src/test04out.txt");
    
            // 追加数据的管道
            OutputStream os =
                    new FileOutputStream("file-io-app/src/test04out.txt", true);
    
            // 2、开始写字节数据出去了
            os.write(97); // 97就是一个字节，代表a
            os.write('b'); // 'b'也是一个字节
            // os.write('磊'); // [ooo] 默认只能写出去一个字节
    
            byte[] bytes = "我爱你中国abc".getBytes();
            os.write(bytes);
    
            os.write(bytes, 0, 15);
    
            // 换行符
            os.write("\r\n".getBytes());
    
            os.close(); // 关闭流
        }
    }

#### 1.6 字节流复制文件 ####

案例：文件复制

需求：

我们要复制一张图片，从磁盘D:/resource/meinv.png的一个位置，复制到C:/data/meinv.png位置。

分析：

> 1.需要创建一个FileInputStream流与源文件接通，创建FileOutputStream与目标文件接通  
> 2.然后创建一个数组，使用FileInputStream每次读取一个字节数组的数据，存如数组中  
> 3.然后再使用FileOutputStream把字节数组中的有效元素，写入到目标文件中

![9d01fe6d8d3e42e88947dc795b60a58b.png][]

代码如下：

/**
     * 目标：使用字节流完成对文件的复制操作。
     */
    public class CopyTest5 {
        public static void main(String[] args) throws Exception {
            // 需求：复制照片。
            // 1、创建一个字节输入流管道与源文件接通
            InputStream is = new FileInputStream("D:/resource/meinv.png");
            // 2、创建一个字节输出流管道与目标文件接通。
            OutputStream os = new FileOutputStream("C:/data/meinv.png");
    
            System.out.println(10 / 0);
            // 3、创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024]; // 1KB.
            // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int len; // 记住每次读取了多少个字节。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
    
            os.close();
            is.close();
            System.out.println("复制完成！！");
        }
    }

### 2、IO流资源释放 ###

前面学习了字节流，强调一下，流使用完之后，一定要释放资源，但是通过close()方法来释放资源并不是很专业。

![9d33898f221e445a8612bcaff8352190.png][]

那这个问题怎么解决呢？在JDK7以前，和JDK7以后分别给出了不同的处理方案。

#### 2.1 JDK7以前的资源释放 ####

在JDK7版本以前，我们可以使用try...catch...finally语句来处理。格式如下：

> try\{  
>  //有可能产生异常的代码  
> \}catch(异常类 e)\{  
> //处理异常的代码  
> \}finally\{  
> //释放资源的代码  
> //finally里面的代码有一个特点，不管异常是否发生，finally里面的代码都会执行。  
> \}

改造上面的代码：

public class Test1 {
        public static void main(String[] args)  {
            InputStream is = null;
            OutputStream os = null;
            try {
                System.out.println(10 / 0);
                // 1、创建一个字节输入流管道与源文件接通
                is = new FileInputStream("file-io-app\\src\\test05.txt");
                // 2、创建一个字节输出流管道与目标文件接通。
                os = new FileOutputStream("file-io-app\\src\\test05copy.txt");
    
                System.out.println(10 / 0);
    
                // 3、创建一个字节数组，负责转移字节数据。
                byte[] buffer = new byte[1024]; // 1KB.
                // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
                int len; // 记住每次读取了多少个字节。
                while ((len = is.read(buffer)) != -1){
                    os.write(buffer, 0, len);
                }
                System.out.println("复制完成！！");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 释放资源的操作
                try {
                    if(os != null) os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    if(is != null) is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

改造后发现，本来几行代码就写完了的，加上try...catch...finally之后多了十几行，而且阅读性也不高。于是....

#### 2.2 JDK7以后的资源释放 ####

上面用try...catch...finally处理异常，并释放资源，代码比较繁琐。Java在JDK7版本为我们提供了一种简化的释放资源的操作，它会自动释放资源。代码写起来也很简单。

格式如下：

> try(资源对象1; 资源对象2;)\{  
> 使用资源的代码  
> \}catch(异常类 e)\{  
> 处理异常的代码  
> \}
> 
> //注意：注意到没有，这里没有释放资源的代码。它会自动释放资源

代码如下：

/**
     * 目标：掌握释放资源的方式：try-with-resource
     */
    public class Test2 {
        public static void main(String[] args)  {
        	try (
              // 1、创建一个字节输入流管道与源文件接通
              InputStream is = new FileInputStream("D:/resource/meinv.png");
              // 2、创建一个字节输出流管道与目标文件接通。
              OutputStream os = new FileOutputStream("C:/data/meinv.png");
            ){
                // 3、创建一个字节数组，负责转移字节数据。
                byte[] buffer = new byte[1024]; // 1KB.
                // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
                int len; // 记住每次读取了多少个字节。
                while ((len = is.read(buffer)) != -1){
                    os.write(buffer, 0, len);
                }
                System.out.println(conn);
                System.out.println("复制完成！！");
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

[0445e53c400e4fcf94632363f5dcaf79.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/09d3cade3afe49bdac7a527b4e9c784d.png
[8056cdead9fb402fa3b48bf1630d6ad3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/8b3b47fbde7841d39fea4d55d53177f3.png
[8c56fc2a3d3f4961866c739485aee4ec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/5dc3318d5269488fafe4302644bc1079.png
[97bccf8448d3479091bc796d2453d5bf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/709fd2fa3f7a4dd4af9c64c122c68ccf.png
[05c2fde4a7d44ad7b4822bbe201d6db4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/9b1baf67b43d4158911a54fe2bc44052.png
[fbb96478812e44ecaccf9b5822d499e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/3fc8cf4625e040d18c7fd7dccebc0e67.png
[965750db0b0f40298ee3d74cf6f59fec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/885dda565eb74c2c9bbb462ec236537a.png
[9d01fe6d8d3e42e88947dc795b60a58b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/d9f5f9df59fc43a6bd971b902e568e57.png
[9d33898f221e445a8612bcaff8352190.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/b40016244c054102b42511fb39c2e9bc.png