我在做管道输入练习时发现一个这样的问题，请大家来指点一下：

1. import java.io.*;
   
2. 
   
3. class PipedOutputStreamDemo
   
4. {
   
5.         public static void main(String []args) throws IOException
   
6.         {
   
7.                 PipedInputStream in = new PipedInputStream();
   
8.                 PipedOutputStream out = new PipedOutputStream();
   
9.                 in.connect(out);
   
10.                 Read r = new Read(in);
    
11.                 Write w = new Write(out);
    
12.                 Thread p1 = new Thread(r);
    
13.                 Thread p2 = new Thread(w);
    
14.                 p1.start();
    
15.                 p2.start();
    
16.         }
    
17. }
    
18. 
    
19. class Read implements Runnable
    
20. {
    
21.         private PipedInputStream in = new PipedInputStream();
    
22.         
    
23.         public void run()
    
24.         {
    
25.                 try
    
26.                 {
    
27.                         byte [] buf = new byte[1024];                             <font color="red"> //这里如果是Byte [] buf = new Byte[1024]时,
    
28.                                                                                                  // String s = new String(buf,0,len);这句话就回出错，
    
29.                                                                                                  //这是为什么呢，难道他们不一样吗？</font>
    
30.           int len = in.read(buf);                              <font color="red"> //还有一点儿就是好像并不存在read(byte[]b)这个方法，
    
31.                                                                          //又没有说明<strong>read</strong>(byte[] b, int off,  int len)
    
32.                                                                          //方法的后面两个参数可以缺省，为什么可以这样用呢？</font>
    
33.           String s = new String(buf,0,len);
    
34.                         System.out.println(s);
    
35.                         in.close();
    
36.                 }
    
37.                 catch(IOException e)
    
38.                 {
    
39.                         throw new RuntimeException("Read Error!");
    
40.                 }
    
41.         }
    
42.         
    
43.          Read(PipedInputStream in)
    
44.         {
    
45.                 this.in = in;
    
46.         }
    
47. }
    
48. 
    
49. class Write implements Runnable
    
50. {
    
51.         private PipedOutputStream out = new PipedOutputStream();
    
52.         
    
53.         Write(PipedOutputStream out)
    
54.         {
    
55.                 this.out = out;
    
56.         }
    
57.         public void run()
    
58.         {
    
59.                 try
    
60.                 {
    
61.                         out.write("piped come on!".getBytes());
    
62.                         out.close();
    
63.                 }
    
64.                 catch(IOException e)
    
65.                 {
    
66.                         throw new RuntimeException ("Write Error!");
    
67.                 }
    
68.         }
    
69. }

复制代码

为什么我提问的那两句话没有变红呢？

Byte [] buf = new Byte[1024]，没有这样的的
byte [] buf = new byte[1024];       

一个字符包装类，一个是基本数据类型

第二个问题是，如果没指定偏移量，默认是数组全部、

一个一个回答
这里如果是Byte [] buf = new Byte[1024]时, String s = new String(buf,0,len);这句话就回出错，
Byte是byte的包装类型。相当于Integer与int的区别，看过有人这样创建int数组吗  Integer[] ins= new Integer[3];
String类有String(byte[] bytes, int offset, int length)这个构造方法，没有String(Byte[] bytes, int offset, int length)这样这样的构造方法
还有一点儿就是好像并不存在read(byte[]b)这个方法。
PipedInputStream从其父类InputStream中继承了read(byte[]b)这个方法。返回的实际读取的字节数。比如读了1024个字节数，则返回去1024。没读满只读了70个字节数的话就返回70.
还有没有变红是因为代码错误。。。

明白了，谢谢{:soso_e181:}