【IO】OutputStream

旧城等待， 2022-05-31 07:09 140阅读 0赞

# 前言 #

Github：[https://github.com/yihonglei/jdk-source-code-reading][https_github.com_yihonglei_jdk-source-code-reading]（java-io）

# 一 概述 #

OutputStream 类是 Java IO API 中所有字节输出流的基类。

![Center][]

# 二 OutputStream 作用 #

OutputStream 是一个抽象类，作为所有字节输出流的基类，OutputStream 作为输出流，将输出流数据写入到目标媒介。

当写入到输出流的数据逐渐输出完毕时，目标媒介是所有数据的归属地。

# 三 OutputStream方法实战 #

OutputStream 中方法源码如下:

public abstract void write(int b) throws IOException;

public void write(byte b\[\]) throws IOException \{ write(b, 0, b.length); \};

public void write(byte b\[\], int off, int len) throws IOException \{ ...... \};

public void flush() throws IOException \{\};

public void close() throws IOException \{\};

以下对每一个方法进行分析。

**write(int b)**

write(int b) 方法用于把单个字节写入到输出流中。OutputStream 的 write(int b)

将一个包含了待写入数据的int变量作为参数写入。只有int类型的第一个字节会被写入，

其余位会被忽略。写入低8位，忽略高24位(API原文: The byte to be written is the eight low-order

bits of the argument b. The 24 high-order bits of b are ignored.)。

OutputStream 的子类可能会包含 write() 方法的替代方法。

比如，DataOutputStream 允许你利用 writeBoolean()，writeDouble() 等方法

将基本类型 int，long，float，double，boolean 等变量写入。

package com.jpeony.io.outputstream;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    
    /**
     * write(int b)：把单个字节写入到输出流中。
     *
     * @author yihonglei
     */
    public class FileOutputStream1 {
        public static void main(String[] args) {
            // 指定构造文件(如果指定文件不存在，会创建对应文件)
            File file = new File("C:\\mycode\\hello.txt");
            // 根据文件创建文件输出流
            try (OutputStream os = new FileOutputStream(file)) {
                // 创建要写入输出流的数据
                String str = "abcdefg";
                byte[] data = str.getBytes();
                // 通过write(int b)将数据写入到输出流，操作系统设备根据输出流处理到终端文件
                for (byte b : data) {
                    os.write(b);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

该实例创建了一个待写入的 FileOutputStream。然后将处理后的字节数据通过 for 循环方式，

每次往输出流写入一个字节，知道数据写入完成然后退出循环。

**write(byte b\[\])**

write(byte b\[\]) 写入字节数组长度的字节到输出流中，也即是将字节数组中全部数据写入到输出流中。

其本质调用的是 write(b, 0, b.length) 方法，也即从 offset 未 0，读取 length 长度的字节数组数据到输出流中。

这样一次性将数据写入到输出流中的方法比单个字节写入到输出流效率高。

package com.jpeony.io.outputstream;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    
    /**
     * write(byte b[])：将字节数组中全部数据写入到输出流中。
     *
     * @author yihonglei
     */
    public class FileOutputStream2 {
        public static void main(String[] args) {
            // 指定构造文件(如果指定文件不存在，会创建对应文件)
            File file = new File("C:\\mycode\\hello.txt");
            // 根据文件创建文件输出流
            try (OutputStream os = new FileOutputStream(file)) {
                // 创建要写入输出流的数据
                String str = "abcdefg";
                byte[] data = str.getBytes();
                // 将数据字节数组一次行写入到FileOutputStream(文件输出流)中
                os.write(data);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

**write(byte b\[\], int off, int len)**

把字节数据中从 offset 位置开始，length 个字节的数据写入到输出流。

package com.jpeony.io.outputstream;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    
    /**
     * write(byte b[], int off, int len)：把字节数据中从offset位置开始，length个字节的数据写入到输出流。
     *
     * @author yihonglei
     */
    public class FileOutputStream3 {
        public static void main(String[] args) {
            // 指定构造文件(如果指定文件不存在，会创建对应文件)
            File file = new File("C:\\mycode\\hello.txt");
            // 根据文件创建文件输出流
            try (OutputStream os = new FileOutputStream(file)) {
                // 创建要写入输出流的数据
                String str = "abcdefg";
                byte[] data = str.getBytes();
                // 从offset位置开始，length个字节的数据写入到输出流
                os.write(data, 1, data.length);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

**flush()**

flush() 方法将所有写入到 OutputStream 的数据冲刷到相应的目标媒介中。

比如，如果输出流是 FileOutputStream，那么写入到其中的数据可能并没有真正写入到磁盘中。

即使所有数据都写入到了 FileOutputStream，这些数据还是有可能保留在内存的缓冲区中。

通过调用 flush() 方法，可以把缓冲区内的数据刷新到磁盘(或者网络，以及其他任何形式的目标媒介)中。

**close()**

当你结束数据写入时，需要关闭 OutputStream。通过调用 close() 方法来关闭。

需要把 close() 方法要放在 finally 块中执行，因为 OutputStream 的各种 write() 方法可能

会抛出 IO 异常，可能未执行到关闭方法，就可能关闭不了流，只有放在 finally 语句块中，

才能保证流的关闭，因为 finally 语句块无论程序是否异常，最后执行语句块中的代码。

虽然这种方式可以确保 OutputStream 关闭，但却不是一个完美的异常处理方案。

在以上实例中，采用了完美的对流关闭的处理，将流的构建放在 try 中进行，当退出 try 时，流会自动关闭。

以上均是在 try 中进行流的关闭，举个在finally语句块中关闭流的实例，但是不推荐使用:

package com.jpeony.io.outputstream;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    
    /**
     * 在finally语句块中关闭流，此方案虽然能关闭流，但是并不完美。
     *
     * @author yihonglei
     */
    public class FileOutputStream4 {
        public static void main(String[] args) {
            // 指定构建文件
            File file = new File("C:\\mycode\\hello.txt");
            OutputStream os = null;
            try {
                // 创建文件输出流
                os = new FileOutputStream(file);
                // 创建要写入输出流的数据
                String str = "abcdefg";
                byte[] data = str.getBytes();
                // 将数据字节数组一次行写入到FileOutputStream(文件输出流)中
                os.write(data);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    // 关闭输出流
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

[https_github.com_yihonglei_jdk-source-code-reading]: https://github.com/yihonglei/jdk-source-code-reading
[Center]: /images/20220531/5375cbc2da4d4bcf980c16dd94ade522.png

【IO】OutputStream

发表评论取消回复

还没有评论，来说两句吧...

相关阅读