Java IO流 - 字节流的使用详细介绍

￡神魔★判官ぃ 2023-09-23 12:59 53阅读 0赞

#### 文章目录 ####

*   *  IO流的基本介绍
     *  字节流的使用
     *   *  文件字节输入流
         *   *  创建字节输入流
             *  每次读取一个字节
             *  每次读取一个数组
             *  一次读取全部字节
         *  文件字节输出流
         *   *  创建字节输出流
             *  写入文件输出流
         *  文件拷贝练习

### IO流的基本介绍 ###

**IO流的概述**:

> I 表示intput，是数据从硬盘文件读入到内存的过程，称之输入，负责读。
> 
> O 表示output，是内存程序的数据从内存到写出到硬盘文件的过程，称之输出，负责写。

![在这里插入图片描述][a33bcbe994074cfdbf570ed9ae334e77.png_pic_center]

**IO流的分类**:

> 按方向分类:
> 
>  *  输入流
>  *  输出流

> 按流中的数据最小单位分为:
> 
>  *  字节流: 可以操作所有类型的文件(*包括音视屏图片等*)
>  *  字符流: 只能操作纯文本的文件(*包括java文件, txt文件等*)

**总结流的四大类**:

> 字节输入流：以内存为基准，来自磁盘文件/网络中的数据以字节的形式读入到内存中去的流称为字节输入流。
> 
> 字节输出流：以内存为基准，把内存中的数据以字节写出到磁盘文件或者网络中去的流称为字节输出流。
> 
> 字符输入流：以内存为基准，来自磁盘文件/网络中的数据以字符的形式读入到内存中去的流称为字符输入流。
> 
> 字符输出流：以内存为基准，把内存中的数据以字符写出到磁盘文件或者网络介质中去的流称为字符输出流。

![在这里插入图片描述][8d3f1a38af62492b9e5a086ca42c0f51.png_pic_center]

### 字节流的使用 ###

![在这里插入图片描述][4175467aba6d44ff86bfab6ea0fd47f0.png_pic_center]

#### 文件字节输入流 ####

##### 创建字节输入流 #####

**文件字节输入流: 实现类FileInputStream**

> 作用：以内存为基准，把磁盘文件中的数据以字节的形式读取到内存中去。

**构造器如下**:

<table> 
 <thead> 
  <tr> 
   <th>构造器</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public FileInputStream(File file)</td> 
   <td>创建字节输入流管道与源文件对象接通</td> 
  </tr> 
  <tr> 
   <td>public FileInputStream(String pathname)</td> 
   <td>创建字节输入流管道与源文件路径接通</td> 
  </tr> 
 </tbody> 
</table>

示例代码:

public static void main(String[] args) throws FileNotFoundException {
        
      	// 写法一: 创建字节输入流与源文件对象接通
        InputStream inp = new FileInputStream(new File("/file-io-app/src/test.txt"));
    }

public static void main(String[] args) throws FileNotFoundException {
        
      	// 写法二: 创建字节输入流管道与源文件路径接通
        InputStream inp = new FileInputStream("/file-io-app/src/test.txt");
    }

--------------------

##### 每次读取一个字节 #####

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>read()</td> 
   <td>每次读取一个字节返回，如果字节已经没有可读的返回-1</td> 
  </tr> 
 </tbody> 
</table>

> 例如我们读取的记事本文件中内容是: abcd123

public static void main(String[] args) throws Exception {
        
        InputStream inp = new FileInputStream("/Users/chenyq/Documents/learn_Java/code/file-io-app/src/test.txt");
    
        int a = inp.read();
        System.out.println(a); // 97
        System.out.println((char) a); // a
    
        // 一次输入一个字节
        System.out.println(inp.read()); // 98
        System.out.println(inp.read()); // 99
        System.out.println(inp.read()); // 100
        System.out.println(inp.read()); // 49
        System.out.println(inp.read()); // 50
        System.out.println(inp.read()); // 51
        // 无字节可读返回-1
        System.out.println(inp.read()); // -1
    }

> 我们可以通过循环遍历出文件中的字节

**每次读取一个字节存在以下问题**

> 性能较慢
> 
> 读取中文字符输出无法避免乱码问题。

--------------------

##### 每次读取一个数组 #####

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>read(byte[] buffer)</td> 
   <td>每次读取一个字节数组, 返回读取了几个字节，如果字节已经没有可读的返回-1</td> 
  </tr> 
 </tbody> 
</table>

> 定义一个字节数组, 用于接收读取的字节数
> 
> 例如下面代码中, 文件中的内容是: abcd123, 每次读取三个字节, 每一次读取都会覆盖上一次数组中的内容, 但是第三次读取只读取了一个字符, 所以只覆盖了上一次读取的字符数组的第一个元素, 结果是: 312

public static void main(String[] args) throws Exception {
        
        InputStream inp = new FileInputStream("/Users/chenyq/Documents/learn_Java/code/file-io-app/src/test.txt");
    
        // 定义一个长度为3的字节数组
        byte[] arr = new byte[3];
    
        // 第一次读取一个字节数组
        int len1 = inp.read(arr);
        System.out.println("读取字节数: " + len1); // 读取字节数: 3
        // 对字节数组进行解码
        String res1 = new String(arr);
        System.out.println(res1); // abc
    
        // 第二次读取一个字节数组
        int len2 = inp.read(arr);
        System.out.println("读取字节数: " + len2); // 读取字节数: 3
        // 对字节数组进行解码
        String res2 = new String(arr);
        System.out.println(res2); // d12
    
        // 第三次读取一个字节数组
        int len3 = inp.read(arr);
        System.out.println("读取字节数: " + len3); // 读取字节数: 1
        // 对字节数组进行解码
        String res3 = new String(arr);
        System.out.println(res3); // 312
    
        // 无字节可读返回-1
        System.out.println(inp.read()); // -1
    }

> String第二个参数可以指定开始位置, 第三个参数可以指定结束位置, 可以用这两个参数解决第三次读取的弊端
> 
> 并且循环改进优化代码

public static void main(String[] args) throws Exception {
        
        InputStream inp = new FileInputStream("/Users/chenyq/Documents/learn_Java/code/file-io-app/src/test.txt");
    
        byte[] arr = new byte[3];
        int len;
        while ((len = inp.read(arr)) != -1) {
        
            String res = new String(arr, 0, len);
            System.out.print(res); // abcd123
        }
    }

**每次读取一个数组存在的弊端**:

> 读取的性能得到了提升
> 
> 读取中文字符输出无法避免乱码问题。

--------------------

##### 一次读取全部字节 #####

> 为解决中文乱码问题我们可以定义一个与文件一样大的字节数组，一次性读取完文件的全部字节。
> 
> 弊端: 如果文件过大，字节数组可能引起内存溢出。

**例如读取如下图这样一个文件**

![在这里插入图片描述][a5a94999daf249fb9d2f58e74b9787f5.png_pic_center]

**方式一**:

> 自己定义一个字节数组与文件的大小一样大，然后使用读取字节数组的方法，一次性读取完成。

public static void main(String[] args) throws Exception {
        
        File file = new File("/Users/chenyq/Documents/learn_Java/code/file-io-app/src/test.txt");
        InputStream inp = new FileInputStream(file);
    
        // 创建一个与文件大小一样的字节数组
        byte[] arr = new byte[(int) file.length()];
    
        // 读取文件, 获取读取的字节长度
        int len = inp.read(arr);
        System.out.println(len); // 252
    
        // 对字节数组进行解码
        String res = new String(arr);
        System.out.println(res);
        // abcd123我爱Java学习Java.abcd123我爱Java学习Java.abcd123我爱Java学习Java.
        // abcd123我爱Java学习Java.abcd123我爱Java学习Java.abcd123我爱Java学习Java.
        // abcd123我爱Java学习Java.abcd123我爱Java学习Java.abcd123我爱Java学习Java.
    }

**方式二**:

> 官方为字节输入流InputStream提供了如下API可以直接把文件的全部数据读取到一个字节数组中

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>readAllBytes()</td> 
   <td>直接读取当前字节输入流对应的文件对象的全部字节数据, 然后装到一个字节数组返回</td> 
  </tr> 
 </tbody> 
</table>

public static void main(String[] args) throws Exception {
        
        InputStream inp = new FileInputStream("/Users/chenyq/Documents/learn_Java/code/file-io-app/src/test.txt");
    
        // 获取文件的全部字节, 并返回一个字节数组
        byte[] arr = inp.readAllBytes();
        // 对字节数组进行解码
        String res = new String(arr);
        System.out.println(res);
        // abcd123我爱Java学习Java.abcd123我爱Java学习Java.abcd123我爱Java学习Java.
        // abcd123我爱Java学习Java.abcd123我爱Java学习Java.abcd123我爱Java学习Java.
        // abcd123我爱Java学习Java.abcd123我爱Java学习Java.abcd123我爱Java学习Java.
    }

#### 文件字节输出流 ####

##### 创建字节输出流 #####

**文件字节输出流: 实现类FileOutputStream**

> 作用：以内存为基准，把内存中的数据以字节的形式写出到磁盘文件中去的流。

**构造器如下**:

<table> 
 <thead> 
  <tr> 
   <th>构造器</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>FileOutputStream(File file)</td> 
   <td>创建字节输出流管道与源文件对象接通</td> 
  </tr> 
  <tr> 
   <td>FileOutputStream(String filepath)</td> 
   <td>创建字节输出流管道与源文件路径接通</td> 
  </tr> 
 </tbody> 
</table>

public static void main(String[] args) throws Exception {
        
        // 写法一: 创建输出流与源文件对象接通
        OutputStream oup = new FileOutputStream(new File("/Users/chenyq/Documents/learn_Java/code/file-io-app/src/test.txt"));
    }

public static void main(String[] args) throws Exception {
        
        // 写法二: 创建输出与源文件路径接通(常用)
        OutputStream oup = new FileOutputStream("/Users/chenyq/Documents/learn_Java/code/file-io-app/src/test.txt");
    
    }

##### 写入文件输出流 #####

**文件字节输出流写数据出去的API**:

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>write(int a)</td> 
   <td>写一个字节出去</td> 
  </tr> 
  <tr> 
   <td>write(byte[] buffer)</td> 
   <td>写一个字节数组出去</td> 
  </tr> 
  <tr> 
   <td>write(byte[] buffer , int pos , int len)</td> 
   <td>写一个字节数组的一部分出去。</td> 
  </tr> 
 </tbody> 
</table>

**流的刷新与关闭API**:

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>flush()</td> 
   <td>刷新流，还可以继续写数据</td> 
  </tr> 
  <tr> 
   <td>close()</td> 
   <td>关闭流，释放资源，但是在<strong>关闭之前会先刷新流</strong>。一旦关闭，就不能再写数据</td> 
  </tr> 
 </tbody> 
</table>

**注意: 写入数据必须刷新数据, 流使用完成后需要关闭**

> 写一个字节出去

public static void main(String[] args) throws Exception {
        
        OutputStream oup = new FileOutputStream("/Users/chenyq/Documents/learn_Java/code/file-io-app/src/test.txt");
    
        oup.write('a');
        // 支持写入编码
        oup.write(97);
        // 汉字占三个字节, 所以该方法不可以写入汉字
        // oup.write('我');
    
        // 写数据必须刷新数据
        oup.flush();
        // 刷新流后可以继续写入数据
        oup.write('b');
        // 使用完后需要关闭流, 关闭后不能再写入数据
        oup.close();
    }

> 写一个字节数组出去

public static void main(String[] args) throws Exception {
        
        OutputStream oup = new FileOutputStream("/Users/chenyq/Documents/learn_Java/code/file-io-app/src/test.txt");
    
        // 定义一个字节数组
        byte[] arr = {
        'a', 98, 'b', 'c'};
        // 写入中文, 需要将中文编码成字节数组
        byte[] chinese = "中国".getBytes();
    
        // 写入英文字节数组
        oup.write(arr);
        // 写入中文字节数组
        oup.write(chinese);
    
        // 关闭流(关闭之前会刷新)
        oup.close();
    }

> 写入一个字节数组的一部分

public static void main(String[] args) throws Exception {
        
        OutputStream oup = new FileOutputStream("/Users/chenyq/Documents/learn_Java/code/file-io-app/src/test.txt");
    
        // 定义一个字节数组
        byte[] arr = {
        'a', 98, 'b', 'c'};
        // 写入数组的第二个和第三个元素
        oup.write(arr, 1, 2);
    
        // 关闭流(关闭之前会刷新)
        oup.close();
    }

**补充知识**:

> 补充一: 写入内容时, 如果需要换行可将`\r\n`(*window支持输入\\n但是有些系统不支持, 为了具备通用性使用\\r\\n*)转为字节数组写入, 实现换行效果

public static void main(String[] args) throws Exception {
        
        OutputStream oup = new FileOutputStream("/Users/chenyq/Documents/learn_Java/code/file-io-app/src/test.txt");
    
        // 定义一个字节数组
        byte[] arr = {
        'a', 98, 'b', 'c'};
        oup.write(arr);
        // 写入换行
        oup.write("\r\n".getBytes());
        // 写入数组的第二个和第三个元素
        oup.write(arr, 1, 2);
    
        // 关闭流(关闭之前会刷新)
        oup.close();
    }

> 补充二: 当写入文件时, 会先将原来文件清空, 再写入新的数据, 如果我们想在原来文件数据的基础上追加新的数据, 这时候就需要将构造器的第二个参数设置为true

<table> 
 <thead> 
  <tr> 
   <th>构造器</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>FileOutputStream(File file，boolean append)</td> 
   <td>创建字节输出流管道与源文件对象接通，可追加数据</td> 
  </tr> 
  <tr> 
   <td>FileOutputStream(String filepath，boolean append)</td> 
   <td>创建字节输出流管道与源文件路径接通，可追加数据</td> 
  </tr> 
 </tbody> 
</table>

public static void main(String[] args) throws Exception {
        
    	  // 设置为true即可
        OutputStream oup = new FileOutputStream("/Users/chenyq/Documents/learn_Java/code/file-io-app/src/test.txt", true);
    }

#### 文件拷贝练习 ####

**需求**:

> 把test.pdf文件复制到其他目录下的newtest.pdf文件中

**思路分析**:

> 根据数据源创建字节输入流对象
> 
> 根据目的地创建字节输出流对象
> 
> 读写数据，复制视频
> 
> 释放资源

**示例代码**:

public static void main(String[] args) {
        
        try {
        
            // 创建要复制文件的字节输入流
            InputStream inp = new FileInputStream("/Users/chenyq/Documents/learn_Java/code/file-io-app/src/test.pdf");
            // 创建目标路径的字节输出流
            OutputStream oup = new FileOutputStream("/Users/chenyq/Documents/newtest.pdf");
    
            // 使用文件输入流获取要复制文件的全部数据的字节数组
            byte[] arr = inp.readAllBytes();
            // 使用文件输出流将字节数组写入目标文件
            oup.write(arr);
            System.out.println("复制成功!");
    
            // 释放资源
            inp.close();
            oup.close();
        } catch (IOException e) {
        
            e.printStackTrace();
        }
    }

**疑问: 字节流可以拷贝什么类型的文件?**

> 任何文件的底层都是字节，拷贝是一字不漏的转移字节，只要前后文件格式、编码一致没有任何问题。  
> 总结: 字节流适合拷贝文件, 但是不适合进行中文的输出输出

[a33bcbe994074cfdbf570ed9ae334e77.png_pic_center]: https://img-blog.csdnimg.cn/a33bcbe994074cfdbf570ed9ae334e77.png#pic_center
[8d3f1a38af62492b9e5a086ca42c0f51.png_pic_center]: https://img-blog.csdnimg.cn/8d3f1a38af62492b9e5a086ca42c0f51.png#pic_center
[4175467aba6d44ff86bfab6ea0fd47f0.png_pic_center]: https://img-blog.csdnimg.cn/4175467aba6d44ff86bfab6ea0fd47f0.png#pic_center
[a5a94999daf249fb9d2f58e74b9787f5.png_pic_center]: https://img-blog.csdnimg.cn/a5a94999daf249fb9d2f58e74b9787f5.png#pic_center