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中讀取這個字元串並輸出它。