Java 17 版本编译的 I/O 基础 InputStream 篇

Java 中的I/O操作，使用流（stream）的概念来介绍。分为输入流 InputStream 和 Reader，输出流OutputStream 和 Writer 作为基类。

Java 中流的类型分为字符型和字节型。

字节流分别是： InputStream 和 OutputStream 类。

字符流分别是：Reader 和 Writer 类。

这些类都是抽象类，具体的实现方法而不是这四个抽象类，而是对应的实现子类。接下来具体的看看这些功能的的使用。这篇主要先来看看输入流的 InputStream 。

InputStream

InputStream 是字节输入流的所有类的超类。 如果想要使用必须继承该类实现对应的抽象方法始终提供返回输入的下一个字节的方法。

抽象类的定义：

public abstract class InputStream implements Closeable

这里实现了 Closeable 并继承了 AutoCloseable 接口。 就可以使用 try-with-resource 语句进行关闭资源。

因为该类并不是一个具体的执行类，而是一个抽象类，它有自己的子类用来具体的执行流的操作。

对应的子类有：

先看该抽象类有哪些方法。

从方法可以看到，read() 方法是比较重要的方法。对于文件系统的读取， 最常用的实现是 FileInputStream。

FileInputStream

对于 FileInputStream 类是从文件系统中的文件中获取输入字节，对于能否获取主要取决于主机的环境或权限。

FileInputStream 用于读取原始的字节流，比方说：图像数据，如果想读取字符流，推荐使用 FileReader 类。

需要注意的是，所有的流操作，都需要手动的调用 close() 方法， 关闭输入流，并释放与之对应的资源。当然也可以使用 try-with-resource 语法调用。

该类的定义：

public class FileInputStream extends InputStream

构造函数定义如下：

简单的案例， 读取一个文件到 System.out 输出

对于 read 方法，会读取输入流到下一个字节，并返回字节表示的一个 int 值。int 值的取值范围是：0 到 255。

如果已经读取到末尾，就会返回 -1 ，所以 -1 可以用来表示读取完毕。

需要注意的是真正读取的方法是一个 native 方法。

private native int readBytes(byte b[], int off, int len) throws IOException;

上面定义了一个存放临时缓存的 byte 变量。因为该文件没有超过 1024 直接就读取出来了。 如果把1024 写成 100 并在循环中打印返回数据， 你将会看到区别。

运行效果：

AudioInputStream

音频输入流，可以操作指定音频格式和音频长度的输入流。长度使用样本帧而不是字节表示。该类中的方法给出了几种方法从流中读取一定数量的字节或未指定数量的字节。

并且给出了一个操作类 javax.sound.sampled.AudioSystem 来自模块 java.desktop 。

这里只给出该类的基本使用方法， 不延伸 AudioSystem 的使用方法。

定义如下：

public class AudioInputStream extends InputStream 

需要先准备一个 wav 的文件， 我这里随便搜索一下系统里面找个 wav 的音频文件。

D:\Program\BaiduNetdisk\sounds\1.wav

演示案例：

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;

public class Input02 {
    public static void main(String[] args) {
        File file = new File("D:\\Program\\BaiduNetdisk\\sounds\\1.wav");
        try (AudioInputStream stream = AudioSystem.getAudioInputStream(file)) {
            Clip clip = AudioSystem.getClip();
            clip.open(stream);
            clip.start();
            // 睡眠一会让 clip 播放音频文件。
            Thread.sleep(500);
        } catch (Exception ex) {
            System.out.println(ex.getMessage());
        }
    }
}

使用命名执行，注意要打开你的音响，要不然也听不到，听不出来效果。

javac -encoding utf-8 Input02.java && java Input02

ByteArrayInputStream

ByteArrayInputStream 包含一个内部缓冲区，其中包含可以从流中读取的字节。 一个内部计数器跟踪由 read 方法提供的下一个字节。 关闭 ByteArrayInputStream 没有任何效果。 可以在关闭流后调用此类中的方法，而不会生成 IOException。

public class ByteArrayInputStream extends InputStream

构造函数有：

直接演示案例：

byte[] buffer = new byte[] { 0, 2, 4, 6, 8, 1, 3, 5, 7, 9 };
try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(buffer);) {
    System.out.print("Buffer 内容: ");
    int i;
    while (byteArrayInputStream.available() > 0) {
        i = byteArrayInputStream.read();
        System.out.print(i + "  ");
    }
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

FilterInputStream

FilterInputStream 包含一些其他输入流，它用作其基本数据源，可能沿途转换数据或提供附加功能。

public class FilterInputStream extends InputStream 

演示代码如下：

ObjectInputStream

ObjectInputStream 反序列化之前使用 ObjectOutputStream 写入的原始数据和对象。

该类的定义：

public class ObjectInputStream
    extends InputStream implements ObjectInput, ObjectStreamConstants

演示案例的第一步：先定义一个 User 类。

import java.io.Serializable;

public class User implements Serializable{
    
    private String uid;
    private String uname;
    
    public User(String uid, String uname) {
        this.uid = uid;
        this.uname = uname;
    }
    
    public String getUid() {
        return uid;
    }
    public void setUid(String uid) {
        this.uid = uid;
    }
    public String getUname() {
        return uname;
    }
    public void setUname(String uname) {
        this.uname = uname;
    }
    
}
@Override
public String toString() {
    return "User [uid=" + uid + ", uname=" + uname + "]";
}

第二步：再创建一个文件 test.txt 文件（这里的 .txt 文件任何名字和后缀都无所谓，但最好有意义）。 对于程序要做的是要写写入序列化的数据到文件中，然后再读取，需要注意的是这里写入的过程知道为什么要写就行。

public static void write() {
    File file = new File("test.txt");
    try (FileOutputStream outputStream = new FileOutputStream(file);
         ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);) {
        objectOutputStream.writeObject(new User("1", "苗子说全栈"));
    } catch (IOException ex) {
        System.out.println(ex.getMessage());
    }
}

完整代码如下：

运行效果：

PipedInputStream

管道输入流应该连接到管道输出流； 管道输入流然后提供写入管道输出流的任何数据字节。 通常，数据由一个线程从 PipedInputStream 对象读取，数据由其他线程写入相应的 PipedOutputStream。 不建议尝试从单个线程使用这两个对象，因为这可能会使线程死锁。 管道输入流包含一个缓冲区，在限制范围内将读取操作与写入操作分离。 如果向连接的管道输出流提供数据字节的线程不再处于活动状态，则称管道已损坏。

定义：

public class PipedInputStream extends InputStream

演示代码如下：

try (PipedInputStream in = new PipedInputStream();
                PipedOutputStream out = new PipedOutputStream(in)) {
    String message = "这里是 PipedInputStream 的演示 ···";
    byte[] buffer = message.getBytes();
    out.write(buffer);

    byte[] b = new byte[100];
    int hasRead = 0;
    while (in.available() > 0) {
        hasRead = in.read(b);
        System.out.println(new String(b, 0, hasRead));
    }
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

SequenceInputStream

SequenceInputStream 表示其他输入流的逻辑串联。 它从输入流的有序集合开始，从第一个流读取，直到到达文件末尾，然后从第二个读取，依此类推，直到在最后一个包含的输入流上到达文件末尾。

定义如下：

public class SequenceInputStream extends InputStream

代码如下：

try (FileInputStream fileInputStream1 = new FileInputStream("Input06.java");
     FileInputStream fileInputStream2 = new FileInputStream("Input06.java");
     SequenceInputStream sequence = new SequenceInputStream(fileInputStream1, fileInputStream2)) {

    byte[] b = new byte[1024];
    int hasRead = 0;
    while ((hasRead = sequence.read(b)) != -1) {
        System.out.println(new String(b, 0, hasRead));
    }
} catch (IOException ex) {
    System.out.println(ex.getMessage());
}

演示案例：

运行效果：

StringBufferInputStream

该类已经过期， 不建议使用。推荐使用 StringReader 类。所以在这不再演示。

这里演示了 InputStream 以及其子类的使用方法。下一篇单独开一片， 来讲解 OutputStream 的使用方法。

知识对于我们来说很重要的，虽然学习的根是苦的，但是学习的果是甜的。

今天的任务完成了吗？点赞，关注，收藏。感谢您的阅读。