输出流转输入流

当有输入流inputstream的数据想要写到数据流outputstream中时，这种情况比较简单，直接read inputstream然后write到outputstream中即可；

当有输出流数据需要转换成输入流使用时，就不那么直观了，我最初的想法是输出流数据写到文件中，然后读文件就转成输入流啦，但是这种利用到硬盘的方法非常不可取的，后来上网查了一下，可以通过管道流PipedStream来实现转换。

首先声明一个维护管道流的类

 1 public class PipedManager {
 2 
 3     private PipedInputStream in = new PipedInputStream();
 4     private PipedOutputStream out = new PipedOutputStream();
 5 
 6     public PipedManager() {
 7         try {
 8             this.in.connect(this.out);
 9         } catch (IOException e) {
10             e.printStackTrace();
11         }
12     }
13 
14     public PipedInputStream getIn() {
15         return in;
16     }
17 
18     public void setIn(PipedInputStream in) {
19         this.in = in;
20     }
21 
22     public PipedOutputStream getOut() {
23         return out;
24     }
25 
26     public void setOut(PipedOutputStream out) {
27         this.out = out;
28     }
29 }

在构造器中通过inputstream.connect方法将输入流和输出流联系到一起

测试类

 1 public class PipedTest {
 2 
 3     public static void main(String[] args) throws IOException {
 4         String readPath = "e:\test.txt";
 5         String writePath = "e:\write.txt";
 6 
 7         FileInputStream inputStream = new FileInputStream(readPath);
 8         PipedManager manager = new PipedManager();
 9         new Thread(){
10             @Override
11             public void run() {
12                 PipedOutputStream out = manager.getOut();
13                 int i = 0;
14                 byte[]buffer = new byte[1024];
15                 try {
16                     while ((i = inputStream.read(buffer,0,buffer.length)) != -1){
17                         out.write(buffer,0,i);
18                         out.flush();
19                     }
20                     out.close();
21                     inputStream.close();
22                 } catch (IOException e) {
23                     e.printStackTrace();
24                 }
25             }
26         }.start();
27 
28 
29         FileOutputStream outputStream = new FileOutputStream(writePath);
30         new Thread(){
31             @Override
32             public void run() {
33                 PipedInputStream in = manager.getIn();
34                 int i = 0;
35                 byte[]buffer = new byte[1024];
36                 try {
37                     while ((i=in.read(buffer,0,buffer.length))!= -1){
38                         outputStream.write(buffer,0,i);
39                     }
40                     in.close();
41                     outputStream.close();
42                 } catch (IOException e) {
43                     e.printStackTrace();
44                 }
45             }
46         }.start();
47     }
48 }

第一个线程是读取一个文件，将其写入到维护的管道输出流中，

第二个线程是直接从管道输入流中获取数据然后写到另外一个文件中，

最终可以看到数据从一个文件写到了另外一个文件，证明输出流的数据可以直接从输入流中获取到。

需要注意的是：我在使用的时候发现数据写到管道输出流这一步必须要起一个线程，也就是第一个线程，不然会一直阻塞