Java InputStream的使用

Java InputStream是java.io包中的一个类，它是所有输入流的抽象基类，其他输入流类型都是从它派生而来的。而InputStream类中定义了一些基本的方法，用来从数据源读取数据。掌握了InputStream的使用方法，我们就可以方便地读取不同数据源的数据。

一、InputStream的基本用法

1、在使用InputStream时，需要先创建一个具体的输入流对象。如下面所示，创建一个继承自InputStream的FileInputStream对象，用于从文件中读取数据：

FileInputStream input = new FileInputStream("filename.txt");

2、使用read()方法读取文件中的数据，下面的代码演示了如何读取文件中的一个字节：

int data = input.read();

Read方法返回文件中下一个字节的整数值。如果已到达文件结尾，则返回-1。

3、使用read(byte[])读取指定长度的数据，下面的代码演示了如何读取文件中的前n个字节数据：

byte[] bytes = new byte[n];
int bytesRead = input.read(bytes);

read(byte[])方法在读取时，会将读取到的数据存放到指定的byte[]数组中，并返回实际读取到的字节数。如果读到文件结尾，则返回-1。

二、InputStream与BufferedInputStream一起使用

1、BufferedInputStream类是InputStream类的一个缓冲类，它使用了一个缓冲区来提高读取效率。通过缓存，我们可以减少实际读取磁盘的次数，从而提高读取速度。

2、使用BufferedInputStream来包装一个普通的InputStream对象：

InputStream input = new FileInputStream("filename.txt");
BufferedInputStream buffer = new BufferedInputStream(input);

3、使用BufferedInputStream的read()方法来读取数据：

int data = buffer.read();
byte[] bytes = new byte[n];
int bytesRead = buffer.read(bytes);

4、关于BufferedInputStream的缓冲区大小，可以使用构造方法中的参数进行指定，默认缓冲区大小为8192。如下面所示：

BufferedInputStream buffer = new BufferedInputStream(input, 1024);

三、InputStream与DataInputStream一起使用

1、在Java中，使用DataInputStream来读取基本数据类型。DataInputStream是一个使用了InputStream的类，它提供了一些方法，用于从输入流中读取基本类型的数据。

2、使用DataInputStream来读取文件中的数据：

InputStream input = new FileInputStream("filename.txt");
DataInputStream dataInput = new DataInputStream(input);

int intValue = dataInput.readInt();       // 读取一个int值
double doubleValue = dataInput.readDouble();  // 读取一个double值

dataInput.close();

3、需要注意的是，如果文件中存储的数据与要读取的类型不匹配，将会抛出EOFException异常。

四、InputStream与ObjectInputStream一起使用

1、ObjectInputStream是一个使用了InputStream的类，它提供了一些方法，用于从输入流中读取Java对象。

2、以下是一个简单的代码示例，它演示了如何使用ObjectInputStream读取文件中的Java对象：

InputStream input = new FileInputStream("object.bin");
ObjectInputStream objectInput = new ObjectInputStream(input);

Object object = objectInput.readObject();

objectInput.close();

3、如果文件中存储的数据与要读取的Java对象不匹配，将会抛出ClassCastException异常。

五、InputStream与ByteArrayInputStream一起使用

1、ByteArrayInputStream是InputStream的一个子类，它使用内存作为数据源，而不是文件或网络。因此，它可以很方便地用来读取字节数组中的数据。

2、在下面的代码中，我们将一个字节数组写入一个ByteArrayInputStream对象中，并读取出其中的数据。

byte[] bytes = {1, 2, 3, 4, 5};
ByteArrayInputStream byteInput = new ByteArrayInputStream(bytes);

int data = byteInput.read();       // 读取一个字节数据
byte[] buffer = new byte[3];
int bytesRead = byteInput.read(buffer);  // 读取3个字节数据

byteInput.close();

六、InputStream与SequenceInputStream一起使用

1、SequenceInputStream是InputStream的另一个子类，它用于将多个输入流按顺序连接在一起，从而形成一个大的输入流。

2、下面的代码演示了如何使用SequenceInputStream将文件1和文件2的内容合并在一起，并写入另一个文件中：

InputStream input1 = new FileInputStream("filename1");
InputStream input2 = new FileInputStream("filename2");
SequenceInputStream sequence = new SequenceInputStream(input1, input2);

OutputStream output = new FileOutputStream("filename3");
byte[] buffer = new byte[1024];
int bytesRead;

while ((bytesRead = sequence.read(buffer)) != -1) {
    output.write(buffer, 0, bytesRead);
}

sequence.close();
input1.close();
input2.close();
output.close();

七、InputStream与PushbackInputStream一起使用

1、PushbackInputStream是InputStream的一个子类，它允许我们将读取的数据推回到输入流中，以便后续从输入流中再次读取数据。

2、下面的代码演示了如何使用PushbackInputStream从字节数组中读取数据，并使用PushbackInputStream将数据推回到输入流中：

byte[] bytes = {1, 2, 3, 4, 5};
ByteArrayInputStream byteInput = new ByteArrayInputStream(bytes);
PushbackInputStream pushbackInput = new PushbackInputStream(byteInput);

int data = pushbackInput.read();   // 读取一个字节数据
System.out.println("读取的数据：" + data);

pushbackInput.unread(data);    // 将数据推回到输入流中

int data2 = pushbackInput.read();  // 再次读取数据
System.out.println("读取的数据：" + data2);

pushbackInput.close();
byteInput.close();

八、InputStream与PipedInputStream一起使用

1、PipedInputStream是InputStream的另一个子类，它允许我们将一个线程的输出流与另一个线程的输入流相连接，从而实现多线程之间的通信。

2、下面的代码演示了如何使用PipedInputStream和PipedOutputStream实现线程之间的通信：

class MyThread1 extends Thread {
    private PipedOutputStream output;

    public MyThread1(PipedOutputStream output) {
        this.output = output;
    }

    public void run() {
        try {
            output.write("Hello".getBytes());
            output.write("World".getBytes());
            output.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class MyThread2 extends Thread {
    private PipedInputStream input;

    public MyThread2(PipedInputStream input) {
        this.input = input;
    }

    public void run() {
        try {
            byte[] buffer = new byte[1024];
            int bytesRead = input.read(buffer);
            String message = new String(buffer, 0, bytesRead);
            System.out.println(message);
            input.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        PipedOutputStream output = new PipedOutputStream();
        PipedInputStream input = new PipedInputStream(output);

        MyThread1 thread1 = new MyThread1(output);
        MyThread2 thread2 = new MyThread2(input);

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();
    }
}

在这个例子中，MyThread1将一个字符串写入PipedOutputStream中，而MyThread2从PipedInputStream中读取这个字符串并输出它。