I/O操作【输入输出流】

叁歲伎倆 2024-03-30 17:21 79阅读 0赞

**目录**

前言

I/O流

管道的分类

方向、粗细组合

子类类型

节点流

操作流

代码演示

输出

输入

文件拷贝

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

## 前言 ##

在算法的概念中，就有“一个算法至少要有一个输出”之说

输入与输出操作是所有程序都必须具备的功能

注意  
所有的输入与输出操作都会**影响性能**；因为它不再是内存中的操作了，而是把内存中的数据与外部进行交互，而这种交互通常比内部操作要慢得多，会有时间上的损耗。

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

## I/O流 ##

Java的I/O操作也经历多次设计，【BIO基本的 IO操作 --->NIO非阻塞的---> AIO异步】每次都是对前一次在某种场景当中的补充，不是替代哦，本文我们主要讲BIO 基本的IO操作。

Java在输入输出时，设计了一个“**流模型**”来表达所有的输入输出动作， 所以BIO又称“I/O流”。

所有的输入与输出，都是在“**数据源**”和“**目的地**”之间建立一根管道，然后数据就像流水一样顺着这根管道从数据源 流向 目的地。

一旦我们确定了数据源和目的地，然后选用一根管道就可以进行I/O操作了。

### **管道的分类** ###

#### **根据方向分类** ####

站在**程序的立场**，确定方向

#### 根据粗细分类 ####

管道粗细指：传递数据的单位 (字节与字符)

<table style="width:580px;"> 
 <tbody> 
  <tr> 
   <td><strong>字节管道</strong></td> 
   <td><strong>字符管道</strong></td> 
  </tr> 
  <tr> 
   <td>传递的最小单位：<strong>byte</strong></td> 
   <td>传递的最小单位：<strong>char</strong></td> 
  </tr> 
  <tr> 
   <td>字节型管道可以传递字符（把char拆分成字节）</td> 
   <td>字符不一定能传字节；比如3个字节的数据，就只能传一次字符，多出来一个无法传递</td> 
  </tr> 
  <tr> 
   <td>传递 <strong>二进制数据</strong></td> 
   <td>传递 <strong>文本数据</strong></td> 
  </tr> 
 </tbody> 
</table>

> **字节型管道是万能的，理论上所有数据都可以传递**。
> 
> 虽然字节型管道能传递字符，但是不方便。输出时，要拆分字符为字节，输入时要组装。

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

### 方向、粗细组合  ###

组合有 四大父类，它们都是 **抽象类**

不能直接使用它们四个，要使用它们的子类，因为它们都只确定了流模型中的一个端点，还有一个端点具有变化性，所以没法实现。

<table style="width:580px;"> 
 <tbody> 
  <tr> 
   <td>InputStream&nbsp;</td> 
   <td>OutputStream&nbsp;</td> 
   <td>Reader</td> 
   <td>Writer&nbsp;</td> 
  </tr> 
  <tr> 
   <td><strong>输入字节流</strong></td> 
   <td><strong>输出字节流</strong></td> 
   <td><strong>输入字符流</strong></td> 
   <td><strong>输出字符流</strong></td> 
  </tr> 
 </tbody> 
</table>

虽然不同的管道有不同的实现，但是操作行为的外观都是一样的，这样就可以调用统一的一个方法。比如：

**输入**需要调用的是**read方法**，它有两种重载形式；

<table style="width:580px;"> 
 <tbody> 
  <tr> 
   <td>int read()</td> 
   <td>int read(byte[ ])&nbsp; / int read(char[ ])</td> 
  </tr> 
  <tr> 
   <td>返回<span style="color:#fe2c24;">单独</span>的字节或字符；</td> 
   <td> <p>读取的数据，以数组的形式放入到参数当中。</p> <p>返回的int代表<span style="color:#fe2c24;">读取了多少个有效的字节或字符</span></p> </td> 
  </tr> 
 </tbody> 
</table>

**输出**需要调用的是**write方法**，有三种重载形式；

<table style="width:580px;"> 
 <tbody> 
  <tr> 
   <td>write(int)</td> 
   <td>write(byte[]) /write(char[])</td> 
   <td> <p>write(byte[],int,int)</p> <p>/write(char[],int,int)</p> </td> 
  </tr> 
  <tr> 
   <td>输出<span style="color:#fe2c24;">单独</span>的字节或字符</td> 
   <td>把整个<span style="color:#fe2c24;">数组</span>中的数据全部输出出去</td> 
   <td> <p><span style="color:#fe2c24;">区域输出</span></p> <p>把数组中，第一个int下标开始，到第二个int下标的元素输出出去</p> </td> 
  </tr> 
 </tbody> 
</table>

### 子类类型 ###

#### **节点流** ####

> 确定管道的另外一个**端点**

要完成一个输入输出操作 必须要用节点流，完善了整个流模型，才可以真正使用。

比如：

InputStream 只确定了 输入和字节型管道；

> FileInputStream 确定了数据源是File（文件）---看首个单词

#### 操作流 ####

> 它是在完成管道对接动作的**中间流**

比如：

我们要传递某种数据到文件，但是此数据不是byte类型。

那么我们需要：

1、通过**操作流**把数据变成byte\[ \]

2、把byte\[ \]交给**节点流** 传到目的地文件。

> 操作流不能单独使用，因为它没有确定另外一个端点。

####  ####

## 代码演示 ##

### 输出 ###

将文本文字传到一篇文件

分析：  
1、这是一个**输出**动作，且是**文本数据**  
所以选用父类Writer  
2、这次输出的**目的地**是一篇**文件**，那么Writer下面有一个  
子类 -- FileWriter  
所以我们需要new出FileWriter的对象，再调write方法输出

##  ##

public static void writePoem(){
            String str= "BroRiver";
            FileWriter fw = null;
            try {
                fw = new FileWriter("name.txt");
                fw.write(str);
            } catch (IOException e) {
                e.printStackTrace();
            } finally{
                if(fw != null){
                    try {
                        fw.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

### 输入 ###

new出 FileReader对象，调用read方法输入

该方法，每次调用返回的是一个**字符**；  
只不过**返回类型是int**，所以需要转换成char；  
当返回的**int为-1**的时候，表示读到了**流的末尾**。

public static String readPoem(){
            String str = "";
            int num = 0;
            try( FileReader fr = new FileReader("name.txt") ){
                while( (num = fr.read()) != -1){
                    str += (char)num;
                }
            } catch (FileNotFoundException e) {
                throw new RuntimeException(e);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            return str;
        }

### **文件拷贝** ###

#### 无参的 read方法 ####

> 每次读取只读取了一个字节，数据量大的话，这里的循环是会被大量执行的

public static void fileCopy() {
            try(FileInputStream fileInput =new FileInputStream("/路径/123.jpg");
                FileOutputStream fileOutput = new FileOutputStream("img/tx.JPG");){
                int num = 0;
                while( (num = fileInput.read()) != -1  ){
                    fileOutput.write(num);
                }
            } catch (FileNotFoundException e) {
                throw new RuntimeException(e);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

#### 带byte\[ \]参数的 read方法 ####

> 每次读取的是byte\[\]长度的字节数，大大减少了循环次数。  
> 但是拷贝后的数据会变大，因为每次都是把整个buffer书写出去了。但最后一次buffer的读取不一定能装满的。

byte[] buffer = new byte[1024];
    while( fileInput.read(buffer) != -1){
    fileOutput.write(buffer);
    }

#### 区域输出 ####

byte[] buffer = new byte[1024];
    int length = 0; 
    while( (length = fileInput.read(buffer)) != -1){
    fileOutput.write(buffer,0,length);
    }