管道流将输入流与输出流直接联系在一起，并且使用于多线程的情况，
那么他的作用有什么呢？我们一般在操作io流的时候不都是先从读取数据然后再写入么？
为什么管道流会先写入之后再读取，假如我想用管道流实现
一个文件的复制应该怎么实现呢，在两个类中如何实现两个文件的关联?下面的程序没有完成，
不知道这种思想是否就是错的，
请各位帮忙解答下

package cn.xushuai.base;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;


class Read implements Runnable{
        private PipedInputStream in;
        Read(PipedInputStream in){
                this.in = in;
        }
        public void run(){
                try{
                FileInputStream fis = new FileInputStream("D:\\myeclipse\\Test\\pipe.txt");
                byte[] buf = new byte[1024];
                int len = 0;
                while((len = in.read(buf))!= -1){
                }
                }
                catch(Exception e){
                        System.out.println("管道流读取失败");
                }
        }
}
class Writer implements Runnable{
        private PipedOutputStream out ;
        Writer(PipedOutputStream out){
                this.out = out;
        }
       
        public void run(){
               
                try{
                FileOutputStream bufw = new FileOutputStream("D:\\myeclipse\\Test\\pipecopy.txt");
                                     //在这里如何实现写入呢？
                }
                catch(Exception e){
                        System.out.println("管道流写入失败");
                }       
        }
       
}
public class PipedDemo {

        /**
         * @param args
         * @throws IOException
         */
        public static void main(String[] args) throws IOException {
                // TODO Auto-generated method stub
                PipedInputStream in = new PipedInputStream();
                PipedOutputStream out = new PipedOutputStream();
                Writer w = new Writer(out);
                  Read r = new Read(in);
                in.connect(out);
                new Thread(r).start();
                new Thread(w).start();
               
        }

}

你的顺序有点问题，其他都没问题，主要是应该用FileInputStream嘛，你用错了。
首先是从管道的写流中把文件写入；再从管道读取流把文件读取；
管道流的写入流用FileInputStream ();而管道的读取流又用到了FileOutputStream （）；
一共四个流，可能有异常，由于管道写流结束导致；但文件复制一定能完成！

1. package cn.itcast.demo;
   
2. 
   
3. import java.io.*;
   
4. 
   
5. public class Piped {
   
6.     public static void main(String[] args) throws IOException {
   
7.         // TODO Auto-generated method stub
   
8.         PipedInputStream in = new PipedInputStream();
   
9.         PipedOutputStream out = new PipedOutputStream();
   
10.         Writer w = new Writer(out);
    
11.           Read r = new Read(in);
    
12.         in.connect(out);
    
13.         new Thread(r).start();
    
14.         new Thread(w).start();
    
15.         
    
16. }
    
17. 
    
18. }
    
19. class Read implements Runnable{
    
20.     private PipedInputStream in;
    
21.     Read(PipedInputStream in){
    
22.             this.in = in;
    
23.     }
    
24.     public void run(){
    
25.             try{
    
26.             FileOutputStream fis = new FileOutputStream("D:\\pipe2.txt");
    
27.             byte[] buf = new byte[1024];
    
28.             int len = 0;
    
29.             while((len = in.read(buf))!= -1)
    
30.             {
    
31.                     fis.write(buf, 0, len);
    
32.             }
    
33.              fis.flush();
    
34. 
    
35.             }
    
36.             catch(Exception e){
    
37.                     System.out.println("管道流读取失败"+e.getMessage());
    
38.             }
    
39.     }
    
40. }
    
41. class Writer implements Runnable{
    
42.     private PipedOutputStream out ;
    
43.     Writer(PipedOutputStream out){
    
44.             this.out = out;
    
45.     }
    
46.    
    
47.     public void run(){
    
48.             
    
49.             try{
    
50.             FileInputStream fi=new FileInputStream("D:\\pipe.txt");
    
51.             byte[] off=new byte[1024];
    
52.             int len=0;
    
53.                 while((len=fi.read(off))!=-1)
    
54.                         {
    
55.                         out.write(off,0,len);
    
56.                         }
    
57.      
    
58.             
    
59.             }
    
60.             catch(Exception e){
    
61.                     System.out.println("管道流写入失败");
    
62.             }  
    
63.             
    
64.   
    
65.     }
    
66.    
    
67. }

复制代码