Java中IO字节流详解

桃扇骨 2023-10-18 22:07 122阅读 0赞

**目录**

一、IO概述

二、字节流

一切皆字节流：

三、字节输出流（OutPutStream）

1、OutPutStream类概述

2、OutPutStream类的成员方法

3、OutPutStream类的子类FileOutputStream（文件字节输出流）

作用：

构造方法：

四、字节输出流入数据到文件

1、写入数据的原理（内存-->硬盘）

2、字节输出流的使用步骤

3、代码演示

运行结果：

五、文件存储的原理

六、字符输出流一次写多个字节的方法

1、方法

2、代码演示

代码：

运行结果：

七、字节输出流的续写和换行

1、使用带两个参数的构造方法

2、代码演示

代码：

运行结果：

换行符：

八、字节输入流（InputStream类）

1、InputStream类

2、InputStream类的成员方法（部分）

3、InputStream类的子类FileInputStream（文件字节输入流）

作用：

构造方法：

九、字节输入流读取字节数据

1、读取数据的原理（硬盘-->内存）

2、字节输入流的使用步骤

3、代码演示

一次只读一个字符：

十、字节输入流读取字节数据的原理

十一、字节流一次读取多个字节的方法

1、代码

2、原理图

3、备注

方法的参数byte\[\]的作用：

方法的返回值int：

十二、练习：文件的复制

1、原理图

2、代码演示

代码：

运行结果：

3、补充知识点

计算程序运行时间的方法：

十三、字节流读取中文的问题

1、原因

2、所以java不仅有字节流，还有字符流！

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

# 一、IO概述 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70][]

#  #

# 二、字节流 #

## 一切皆字节流： ##

一切文件数据在存储时，都是以二进制的形式保存到，都是一个一个字节，那么传输时也是如此，所以字节流可以读取任何形式的文件数据；在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的都是二进制数据。

# 三、字节输出流（OutPutStream） #

## 1、OutPutStream类概述 ##

①是抽象类（抽象类是无法实例化对象的，用其子类）；

②是所有字节输出流最顶层的父类；

③定义了一些子类共性的成员方法；

④重点研究子类FileOutputStream；

## 2、OutPutStream类的成员方法 ##

①void close()关闭此输出流并释放与此流有关的所有系统资源；

②void flush() 刷新此输出流并强制写出所有缓冲的输出字节；

③void write(byte\[\] b)将 b.length 个字节从指定的 byte 数组写入此输出流；

④void write(byte\[\] b, int off, int len)将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流；

⑤abstract void write(int b)将指定的字节写入此输出流；

##    3、OutPutStream类的子类FileOutputStream（文件字节输出流） ##

### 作用： ###

将内存中的数据写入到硬盘的文件中；

### 构造方法： ###

**FileOutputStream(File file)**

创建一个向指定 File 对象表示的文件中写入数据的文件输出流；

**FileOutputStream(String name)**

创建一个向具有指定名称的文件中写入数据的输出文件流；

**注意：**参数是写入文件的目的地；

**构造方法的作用：**

①创建一个FileOutputStream对象；

②会根据构造方法传递的文件/文件路径，创建一个而空的文件；

③会把FileOutputStream对象指向创建好的文件；

# 四、字节输出流入数据到文件 #

## 1、写入数据的原理（内存-->硬盘） ##

java程序-->JVM虚拟机-->OS（操作系统）-->OS调用其写数据的方法-->将数据写到文件中

## 2、字节输出流的使用步骤 ##

①创建一个FileOutputStream对象，构造方法中传入数据的目的地（问价对象或者地址）；

②调用FileOutputStream中的write，把数据写入到文件中；

③释放内存资源，提高程序效率；

## 3、代码演示 ##

### 运行结果： ###

![20190720103628745.png][]

# 五、文件存储的原理 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 1][]

# 六、字符输出流一次写多个字节的方法 #

## 1、方法 ##

void write(byte\[\] b)将 b.length 个字节从指定的 byte 数组写入此输出流；

void write(byte\[\] b, int off, int len)将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流；

## 2、代码演示 ##

### 代码： ###

package study.io;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class FileOutputStreamTest {
        public static void main(String[] args) throws IOException {
            //①创建一个FileOutputStream对象，构造方法中传入数据的目的地（问价对象或者地址）；
            FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test.txt");
            //②调用FileOutputStream中的write，把数据写入到文件中；
            String string = "hello world!";
            //写全部进去
            fileOutputStream.write(string.getBytes());
            //写一部分进去
            fileOutputStream.write(string.getBytes(),2,5);
            //③释放内存资源，提高程序效率；
            fileOutputStream.close();
        }
    }

### 运行结果： ###

![20190720112046618.png][]

# 七、字节输出流的续写和换行 #

## 1、使用带两个参数的构造方法 ##

FileOutputStream(File file, boolean append)创建一个向指定 File 对象表示的文件中写入数据的文件输出流；

FileOutputStream(String name, boolean append)创建一个向具有指定 name 的文件中写入数据的输出文件流；

**参数说明：file和name是目的地，append是追加写入的开关；**

## 2、代码演示 ##

## 代码： ##

package study.io;
    
            import java.io.FileOutputStream;
            import java.io.IOException;
    
    public class FileOutputStreamTest {
        public static void main(String[] args) throws IOException {
            //①创建一个FileOutputStream对象，构造方法中传入数据的目的地（问价对象或者地址）；
            FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test.txt",true);
            //②调用FileOutputStream中的write，把数据写入到文件中；
            //组织一个字符串作为要写入的内容-并加入换行
            String string = "\r\n前面是之前已有的数据内容\r\n";
            //写全部进去
            fileOutputStream.write(string.getBytes());
            //组织一个字符串作为要写入的内容-并加入换行
            String string1 = "这是刚刚写入的新的内容啦========";
            //写全部进去
            fileOutputStream.write(string1.getBytes());
            //③释放内存资源，提高程序效率；
            fileOutputStream.close();
        }
    }

## 运行结果： ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 2][]

## 换行符： ##

Windows系统：\\r\\n

Linux系统：/n

Mac系统：/r

# 八、字节输入流（InputStream类） #

## 1、InputStream类 ##

①是抽象类（抽象类是无法实例化对象的，用其子类）；

②是所有字节输出流最顶层的父类；

③定义了一些子类共性的成员方法；

④重点研究子类FileInputStream；

## 2、InputStream类的成员方法（部分） ##

①void close()关闭此输入流并释放与该流关联的所有系统资源；

②abstract int read()从输入流中读取数据的下一个字节；

③int read(byte\[\] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中；

## 3、InputStream类的子类FileInputStream（文件字节输入流） ##

### 作用： ###

把硬盘文件中的数据，读取到内存中使用；

### 构造方法： ###

**FileInputStream(File file)**

通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定；

**FileInputStream(String name)**

通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定；

**参数：读取文件的数据源file：文件对象；name：文件的路径；**

**构造方法的作用：**

①创建一个FileInputStream对象；

②会把FileInputStream对象指向构造方法中要读取的文件；

# 九、字节输入流读取字节数据 #

## 1、读取数据的原理（硬盘-->内存） ##

java程序-->JVM虚拟机-->OS（操作系统）-->OS调用其读取数据的方法-->将数据读取到内存中

## 2、字节输入流的使用步骤 ##

①创建一个FileInputStream对象，构造方法中传入数据的目的地（问价对象或者地址）；

②调用FileInputStream中的read，把数据写入到文件中；

③释放内存资源，提高程序效率；

## 3、代码演示 ##

### 一次只读一个字符： ###

package study.io;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    public class FileInputStreamTest {
        public static void main(String[] args) throws IOException {
            //①创建一个FileInputStream对象，构造方法中传入数据的目的地（问价对象或者地址）；
            FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Administrator\\Desktop\\test.txt");
            //备注：文件中的内容是abc
            //②调用FileInputStream中的read，把数据写入到文件中；
            System.out.println(fileInputStream.read());//97 a
            System.out.println(fileInputStream.read());//98 b
            System.out.println(fileInputStream.read());//99 c
            System.out.println(fileInputStream.read());//读到末尾了，返回-1
            //③释放内存资源，提高程序效率；
            fileInputStream.close();
        }
    }

###  ###

# 十、字节输入流读取字节数据的原理 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 3][]

# 十一、字节流一次读取多个字节的方法 #

## 1、代码 ##

package study.io;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.util.Arrays;
    
    public class FileInputStreamTest {
        public static void main(String[] args) throws IOException {
            //①创建一个FileInputStream对象，构造方法中传入数据的目的地（问价对象或者地址）；
            FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Administrator\\Desktop\\test.txt");
            //备注：文件中的内容是abc
            //②调用FileInputStream中的read，把数据写入到文件中；
            byte[] bytes = new byte[3];
            int len = fileInputStream.read(bytes);
            System.out.println(len);//3
            System.out.println(Arrays.toString(bytes));//[97, 98, 99]
            System.out.println(new String(bytes));//abc
            len = fileInputStream.read(bytes);
            System.out.println(len);//-1，此时数据读完，返回-1
            System.out.println(Arrays.toString(bytes));//[97, 98, 99]
            System.out.println(new String(bytes));//abc
            //③释放内存资源，提高程序效率；
            fileInputStream.close();
        }
    }

##  ##

## 2、原理图 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 4][]

## 3、备注 ##

### 方法的参数byte\[\]的作用： ###

启动缓冲的作用，存储每次读到的多个字节；

数组的长度一般定义为1024（1KB）或者1024的整数倍；

### 方法的返回值int： ###

每次读取到的**有效**字节数量；

返回-1表示读取到末尾了；

# 十二、练习：文件的复制 #

## 1、原理图 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 5][]

## 2、代码演示 ##

### 代码： ###

package study.io;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class FileCopy {
        public static void main(String[] args) throws IOException {
            /*
            * ====要想实现文件复制，必须明确的几点：
            * 1、数据源：‪C:\Users\Administrator\Desktop\1.jpg
            * 2、数据复制的目的地：C:\Users\Administrator\Desktop\2.jpg
            * ====文件复制的步骤：
            * 1、创建一个字节输入流对象，构造方法中传入要读取的数据源
            * 2、创建一个字节输出流对象，构造方法中绑定要写入的目的地
            * 3、使用字节输入了的read读取文件；
            * 4、使用字节输出流的write写入文件；
            * 5、释放资源
            * */
            FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Administrator\\Desktop\\1.jpg");
            FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\2.jpg");
            byte[] bytes = new byte[1024];
            while (fileInputStream.read(bytes)!=-1){
                fileOutputStream.write(bytes);
            }
            fileOutputStream.close();
            fileInputStream.close();
        }
    }

### 运行结果： ###

### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 6][] ###

## 3、补充知识点 ##

### 计算程序运行时间的方法： ###

package study.io;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class FileCopy {
        public static void main(String[] args) throws IOException {
            /*
            * ====要想实现文件复制，必须明确的几点：
            * 1、数据源：‪C:\Users\Administrator\Desktop\1.jpg
            * 2、数据复制的目的地：C:\Users\Administrator\Desktop\2.jpg
            * ====文件复制的步骤：
            * 1、创建一个字节输入流对象，构造方法中传入要读取的数据源
            * 2、创建一个字节输出流对象，构造方法中绑定要写入的目的地
            * 3、使用字节输入了的read读取文件；
            * 4、使用字节输出流的write写入文件；
            * 5、释放资源
            * */
            //开始计时
            long s = System.currentTimeMillis();
            FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Administrator\\Desktop\\1.jpg");
            FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\2.jpg");
            byte[] bytes = new byte[1024];
            while (fileInputStream.read(bytes)!=-1){
                fileOutputStream.write(bytes);
            }
            fileOutputStream.close();
            fileInputStream.close();
            long e = System.currentTimeMillis();
            System.out.println("程序执行耗时："+(e-s)+"毫秒");//程序执行耗时：15毫秒
        }
    }

# 十三、字节流读取中文的问题 #

## 1、原因 ##

中文，gbk占用2个字节，utf-8占用3个字节，所以当读取一个字节的时候中文是显示不全的；

## 2、所以java不仅有字节流，还有字符流！ ##

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190720095606328.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70
[20190720103628745.png]: https://img-blog.csdnimg.cn/20190720103628745.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190720111320893.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70
[20190720112046618.png]: https://img-blog.csdnimg.cn/20190720112046618.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20190720113438645.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20190720122307909.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20190720123300137.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20190720123830737.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20190720124952762.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70