ByteArrayOutputStream和ByteArrayInputStream详解 &&&管道流

 ByteArrayOutputStream类是在创建它的实例时，程序内部创建一个byte型别数组的缓冲区，然后利用ByteArrayOutputStream和ByteArrayInputStream的实例向数组中写入或读出byte型数据。在网络传输中我们往往要传输很多变量，我们可以利用ByteArrayOutputStream把所有的变量收集到一起，然后一次性把数据发送出去。具体用法如下:

ByteArrayOutputStream:    可以捕获内存缓冲区的数据，转换成字节数组。

ByteArrayInputStream: 可以将字节数组转化为输入流

 1 import java.io.*;
 2
 3 public class test  {
 4  public static void main(String[] args)  {
 5   int a=0;
 6   int b=1;
 7   int c=2;
 8   ByteArrayOutputStream bout = new ByteArrayOutputStream();
 9   bout.write(a);
10   bout.write(b);
11   bout.write(c);
12   byte[] buff = bout.toByteArray();
13   for(int i=0; i<buff.length; i++)
14    System.out.println(buff[i]);
15   System.out.println("***********************");
16   ByteArrayInputStream bin = new ByteArrayInputStream(buff);
17   while((b=bin.read())!=-1)  {
18    System.out.println(b);
19   }
20  }
21 }
22
23
24

如上所示,ByteArrayOutputStream把内存中的数据读到字节数组中,而ByteArrayInputStream又把字节数组中的字节以流的形式读出,实现了对同一个字节数组的操作.

综合DataOutputStream&DataInputStream的作用和功能,与ByteArrayOutputStream和ByteArrayInputSream使用将更方便.此时DataOutputStream&DataInputStream封闭了字节流,以适当的形式读出了字节数组中的数据.如下所示:

 1 import java.io.*;
 2
 3 public class test  {
 4  public static void main(String[] args)throws IOException  {
 5   ByteArrayOutputStream bout = new ByteArrayOutputStream();
 6   DataOutputStream dout = new DataOutputStream(bout);
 7   String name = "xxy";
 8   int age = 84;
 9   dout.writeUTF(name);
10   dout.writeInt(age);
11   byte[] buff = bout.toByteArray();
12   ByteArrayInputStream bin = new ByteArrayInputStream(buff);
13   DataInputStream dis = new DataInputStream(bin);
14   String newName = dis.readUTF();
15   int newAge = dis.readInt();
16   System.out.println(newName+":"+newAge);
17  }
18 }
管道流

管道流的主要作用是可以进行两个线程间的通信，如图12-9所示，分为管道输出流（PipedOutputStream）和管道输入流（PipedInputStream）。如果要进行管道输出，则必须把输出流连在输入流上，在PipedOutputStream类上有如下方法用于连接管道。

  
  
public void connect
(PipedInputStream snk) throws IOException 

（点击查看大图）图12-9  管道流操作

范例：验证管道流

  
  
package org.lxh.demo12.pipeddemo;  
import java.io.IOException;  
import java.io.PipedInputStream;  
import java.io.PipedOutputStream;  
class Send implements Runnable {          
// 实现Runnable接口  
    private PipedOutputStream pos = null;   // 管道输出流  
    public Send() {  
        this.pos = new PipedOutputStream();// 实例化输出流  
    }  
    public void run() {  
        String str = "Hello World!!!";  
        try {  
            this.pos.write(str.getBytes()); // 输出信息  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        try {  
            this.pos.close();               // 关闭输出流  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
    public PipedOutputStream getPos() { // 通过线程类得到输出流  
        return pos;  
    }  
}  
class Receive implements Runnable {     // 实现Runnable接口  
    private PipedInputStream pis = null;  
    public Receive() {  
        this.pis = new PipedInputStream();  // 实例化输入流  
    }  
    public void run() {  
        byte b[] = new byte[1024];  
        int len = 0;  
        try {  
            len = this.pis.read(b);         // 接收数据  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        try {  
            this.pis.close();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        System.out.println("接收的内容为：" + new String(b, 0, len));  
    }  
    public PipedInputStream getPis() {  
        return pis;  
    }  
}  
public class PipedDemo {  
    public static void main(String[] args) {  
        Send s = new Send();  
        Receive r = new Receive();  
        try {  
            s.getPos().connect(r.getPis()); // 连接管道  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        new Thread(s).start();              // 启动线程  
        new Thread(r).start();              // 启动线程  
    }  
} 

程序运行结果：

接收的内容为：Hello World!!!

以上程序定义了两个线程对象，在发送的线程类中定义了管道输出流，在接收的线程类中定义了管道的输入流，在操作时只需要使用PipedOutputStream类中提供的connection()方法就可以将两个线程管道连接在一起，线程启动后会自动进行管道的输入、输出操作。