Java中的字节流

分手后的思念是犯贱 2022-01-29 18:09 239阅读 0赞

## 第一章 IO概述 ##

**1.1 什么是IO**  
生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了 ctrl+s ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。  
我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为 输入input 和输出output ，即流向内存是输入流，流出内存的输出流。  
Java中I/O操作主要是指使用 [java.io][] 包下的内容，进行输入、输出操作。**输入也叫做读取数据，输出也叫做作写出数据。**  
**1.2 IO的分类**  
根据数据的流向分为：**输入流和输出流。**

*  **输入流** ：把数据从其他设备上读取到内存中的流。
 *  **输出流** ：把数据从 内存 中写出到 其他设备上的流。  
    格局数据的类型分为：**字节流和字符流。**
 *  **字节流** ：以字节为单位，读写数据的流。
 *  **字符流** ：以字符为单位，读写数据的流。  
    **1.3 IO的流向说明图解**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70]**1.4 顶级父类们**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 1]

## 第二章 字节流 ##

**2.1 一切皆为字节**  
一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，**字节流可以传输任意文件数据**。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，**底层传输的始终为二进制数据**。  
**2.2 字节输出流【OutputStream】**  
*java.io.OutputStream* 抽象类是表示**字节输出流的所有类的超**类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

*  public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
 *  public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
 *  public void write(byte\[\] b) ：将 b.length字节从指定的字节数组写入此输出流。
 *  public void write(byte\[\] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量  
    off开始输 出到此输出流。
 *  public abstract void write(int b) ：将指定的字节输出流。
 *  小贴士： close方法，当完成流的操作时，必须调用此方法，释放系统资源。  
    **2.3 FileOutputStream类**  
    OutputStream 有很多子类，我们从最简单的一个子类开始。  
    java.io.FileOutputStream 类是文件输出流，用于将数据写出到文件。  
    **构造方法**
 *  public FileOutputStream(File file) ：创建文件输出流以写入由指定的 File对象表示的文件。
 *  public FileOutputStream(String name) ： 创建文件输出流以指定的名称写入文件。  
    当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。  
    **构造举例，代码如下：**

public class FileOutputStreamConstructor throws IOException {
        public static void main(String[] args) {
         // 使用File对象创建流对象    
            File file = new File("a.txt");
            FileOutputStream fos = new FileOutputStream(file);
         
            // 使用文件名称创建流对象
            FileOutputStream fos = new FileOutputStream("b.txt");
        }
    }

**写出字节数据**

1.  **写出字节**： write(int b) 方法，每次可以写出一个字节数据，代码使用演示：

public class FOSWrite {
     public static void main(String[] args) throws IOException {
            // 使用文件名称创建流对象
            FileOutputStream fos = new FileOutputStream("fos.txt");    
           // 写出数据  
           fos.write(97); // 写出第1个字节  
           fos.write(98); // 写出第2个字节  
           fos.write(99); // 写出第3个字节  
           // 关闭资源  
            fos.close();
        }
    }
    输出结果：
    abc

*  小贴士：  
    1. 虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。  
    2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。

1.  写出字节数组： write(byte\[\] b) ，每次可以写出数组中的数据，代码使用演示：

public class FOSWrite {
        public static void main(String[] args) throws IOException {
            // 使用文件名称创建流对象
            FileOutputStream fos = new FileOutputStream("fos.txt");    
           // 字符串转换为字节数组  
           byte[] b = "坏小孩".getBytes();  
           // 写出字节数组数据  
           fos.write(b);  
           // 关闭资源  
            fos.close();
        }
    }
    输出结果：
    坏小孩

1.  **写出指定长度字节数组**： write(byte\[\] b, int off, int len) ,每次写出从off索引开始，len个字节，**代码使用演示**：

public class FOSWrite {
        public static void main(String[] args) throws IOException {
            // 使用文件名称创建流对象
            FileOutputStream fos = new FileOutputStream("fos.txt");    
           // 字符串转换为字节数组  
           byte[] b = "abcde".getBytes();  
    // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。        
            fos.write(b,2,2);
           // 关闭资源  
            fos.close();
        }
    }
    输出结果：
    cd

**数据追加续写**  
经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？

*  public FileOutputStream(File file, boolean append) ： 创建文件输出流以写入由指定的  
    File对象表示的 文件。
 *  public FileOutputStream(String name, boolean append) ：  
    创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值， true 表示追加数据， false 表示清空原有数据。  
这样创建的输出流对象，就可以指定是否追加续写了，**代码使用演示**：

public class FOSWrite {
        public static void main(String[] args) throws IOException {
            // 使用文件名称创建流对象
            FileOutputStream fos = new FileOutputStream("fos.txt"，true);    
           // 字符串转换为字节数组  
           byte[] b = "abcde".getBytes();  
    // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。        
            fos.write(b);
           // 关闭资源  
            fos.close();
        }
    }
    文件操作前：cd
    文件操作后：cdabcde

**写出换行**  
Windows系统里，换行符号是 \\r\\n 。指定是否追加续写了，**代码使用演示**：

public class FOSWrite {
        public static void main(String[] args) throws IOException {
            // 使用文件名称创建流对象
            FileOutputStream fos = new FileOutputStream("fos.txt"); 
           // 定义字节数组  
           byte[] words = {97,98,99,100,101};  
           // 遍历数组  
            for (int i = 0; i < words.length; i++) {
               // 写出一个字节  
                fos.write(words[i]);
               // 写出一个换行, 换行符号转成数组写出  
                fos.write("\r\n".getBytes());
            }
           // 关闭资源  
            fos.close();
        }
    }
    
    输出结果：
    a
    b
    c
    d
    e

*  注意事项：
 *  回车符 \\r 和换行符 \\n ： 回车符：回到一行的开头（return）。 换行符：下一行（newline）。 系统中的换行：
 *  Windows系统里，每行结尾是 回车+换行 ，即 \\r\\n ； Unix系统里，每行结尾只有 换行 ，即 \\n
 *  Mac系统里，每行结尾是 回车 ，即 \\r 。从 Mac OS X开始与Linux统一。  
    **2.4 字节输入流【InputStream】**  
    java.io.InputStream 抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
 *  public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
 *  public abstract int read() ： 从输入流读取数据的下一个字节。
 *  public int read(byte\[\] b) ： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。
 *  小贴士：
 *  close方法，当完成流的操作时，必须调用此方法，释放系统资源。  
    **2.5 FileInputStream类**  
    java.io.FileInputStream 类是文件输入流，从文件中读取字节。  
    **构造方法**
 *  FileInputStream(File file) ： 通过打开与实际文件的连接来创建一个 FileInputStream  
    ，该文件由文件系统中的 File对象 file命名。
 *  FileInputStream(String name) ： 通过打开与实际文件的连接来创建一个 FileInputStream  
    ，该文件由文件系统中的路径名 name命名。  
    当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出 FileNotFoundException 。  
    **构造举例，代码如下：**

public class FileInputStreamConstructor throws IOException{
        public static void main(String[] args) {
         // 使用File对象创建流对象    
            File file = new File("a.txt");
            FileInputStream fos = new FileInputStream(file);
         
            // 使用文件名称创建流对象
            FileInputStream fos = new FileInputStream("b.txt");
        }
    }

**读取字节数据**

1.  读取字节： read 方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回 -1 ，**代码使用演示**：

public class FISRead {
        public static void main(String[] args) throws IOException{
           // 使用文件名称创建流对象  
           FileInputStream fis = new FileInputStream("read.txt"); 
           // 读取数据，返回一个字节  
            int read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println((char) read);
           // 读取到末尾,返回‐1  
           read = fis.read(); 
            System.out.println( read);
    // 关闭资源        
            fis.close();
        }
    }
    输出结果：
    a
    b
    c
    d
    e
    ‐1

循环改进读取方式，代码使用演示：

public class FISRead {
        public static void main(String[] args) throws IOException{
           // 使用文件名称创建流对象
           FileInputStream fis = new FileInputStream("read.txt"); 
           // 定义变量，保存数据  
            int b ；
            // 循环读取
            while ((b = fis.read())!=‐1) {
                System.out.println((char)b);
            }
    // 关闭资源        
            fis.close();
        }
    }
    输出结果：
    a
    b
    c
    d
    e

*  小贴士：

1.  虽然读取了一个字节，但是会自动提升为int类型。
2.  流操作完毕后，必须释放系统资源，调用close方法，千万记得。
3.  使用字节数组读取： read(byte\[\] b) ，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回 -1 ，**代码使用演示**：

public class FISRead {
        public static void main(String[] args) throws IOException{
           // 使用文件名称创建流对象.  
           FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde 
           // 定义变量，作为有效个数  
            int len ；
            // 定义字节数组，作为装字节数据的容器  
            byte[] b = new byte[2];
            // 循环读取
            while (( len= fis.read(b))!=‐1) {
               // 每次读取后,把数组变成字符串打印 
                System.out.println(new String(b));
            }
    // 关闭资源        
            fis.close();
        }
    }
    输出结果：
    ab
    cd
    ed

错误数据 d ，是由于最后一次读取时，只读取一个字节 e ，数组中，上次读取的数据没有被完全替换，所以要通过 len ，获取有效的字节，**代码使用演示**：

public class FISRead {
        public static void main(String[] args) throws IOException{
           // 使用文件名称创建流对象.  
           FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde 
           // 定义变量，作为有效个数  
            int len ；
            // 定义字节数组，作为装字节数据的容器  
            byte[] b = new byte[2];
            // 循环读取
            while (( len= fis.read(b))!=‐1) {
               // 每次读取后,把数组的有效字节部分，变成字符串打印 
                System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数
            }
    // 关闭资源        
            fis.close();
        }
    }
    输出结果：
    ab
    cd
    e

*  小贴士：
 *  使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。  
    **2.6 字节流练习：图片复制**  
    **复制原理图解**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 2]复制图片文件，**代码使用演示：**

public class Copy {
        public static void main(String[] args) throws IOException {
            // 1.创建流对象
            // 1.1 指定数据源
            FileInputStream fis = new FileInputStream("D:\\test.jpg");
            // 1.2 指定目的地
            FileOutputStream fos = new FileOutputStream("test_copy.jpg");
            // 2.读写数据
            // 2.1 定义数组
            byte[] b = new byte[1024];
            // 2.2 定义长度
            int len;
            // 2.3 循环读取
            while ((len = fis.read(b))!=‐1) {
                // 2.4 写出数据
                fos.write(b, 0 , len);
            }
            // 3.关闭资源
            fos.close();
            fis.close();
        }
    }

*  小贴士： 流的关闭原则：先开后关，后开先关。

[java.io]: http://java.io
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70]: /images/20220126/fe7ac18d7b1f423c866d2242250b3df0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 1]: /images/20220126/7f71f1ddf2834c1ab4c0dfdd060d33e6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 2]: /images/20220126/a2482fd54ba14d88a4b9204f2ab90456.png