有时候，我们需要将读取文件的内容到一个byte[] 数组中，然后对这个数组进行一些修改，这时，我们可以借助于ByteArrayOutputStream 这个类来实现。
    ByteArrayOutputStream，顾名思义，同样是一个OutputStream，那么，对于它的写入操作，和其他的 OutputStream应该是没有什么两样，写入代码可以说是随手拈来的，与其他输出流的不同之处在于，ByteArrayOutputStream写入到内存中，并提供一个 toByteArray() 方法返回我们所需要的byte[]。
    　
    Java代码
    //保存上传的附件信息
        String filename = files[0];
        String filepath = "upload/append/"+files[1];
                            BufferedInputStream in = new BufferedInputStream(new FileInputStream(filepath));
                            ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
                            System.out.println("available bytes"+in.available());
        byte[] temp = new byte[2048];
        int size =0;
        while((size = in.read(temp))!=-1){                 out.write(temp,0,size);
        }
        in.close();
        byte[] content = out.toByteArray();

        String stream = new BaseCode64().EncodeBase64(content);
        System.out.println("content" +content.length);
             effect += insertAttachmentInfo(conn,attNo,processId,filename,stream);
    这里把读取的流以base64保存，使用了类BaseCode64()的方法EncodeBase64。
    代码如下：
    Java代码

    package com.ving.xzfw.util;

    import java.io.ByteArrayOutputStream;

    public class BaseCode64 {
        private String TableBase64;
        private String FError;

        public BaseCode64()
        {
            TableBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
            FError = new String();
            FError = "";
        }
        public String DecodeBase64(byte [] Value){

            ByteArrayOutputStream o = new ByteArrayOutputStream();
            byte d[] = new byte[4];
            try
            {
                int count = 0;
                byte x[] = Value;
                do
                {
                    if(count >= x.length)
                    {
                        break;
                    }
                    for(int n = 0; n <= 3; n++)
                    {
                        if(count >= x.length)
                        {
                            d[n] = 64;
                        } else
                        {
                            int y = TableBase64.indexOf(x[count]);
                            if(y < 0)
                            {
                                y = 65;
                            }
                            d[n] = (byte)y;
                        }
                        count++;
                    }

                    o.write((byte)(((d[0] & 0x3f) << 2) + ((d[1] & 0x30) >> 4)));
                    if(d[2] != 64)
                    {
                        o.write((byte)(((d[1] & 0xf) << 4) + ((d[2] & 0x3c) >> 2)));
                        if(d[3] != 64)
                        {
                            o.write((byte)(((d[2] & 3) << 6) + (d[3] & 0x3f)));
                        }
                    }
                } while(true);
            }
            catch(StringIndexOutOfBoundsException e)
            {
                FError = String.valueOf(String.valueOf(FError)) + String.valueOf(String.valueOf(e.toString()));
                System.out.println(e.toString());
            }
            return o.toString();

        }

        public String EncodeBase64(byte [] Value){
            ByteArrayOutputStream o = new ByteArrayOutputStream();
            byte d[] = new byte[4];
            try
            {
                int count = 0;
                for(byte x[] = Value; count < x.length;)
                {
                    byte c = x[count];
                    count++;
                    d[0] = (byte)((c & 0xfc) >> 2);
                    d[1] = (byte)((c & 3) << 4);
                    if(count < x.length)
                    {
                        c = x[count];
                        count++;
                        d[1] = (byte)(d[1] + (byte)((c & 0xf0) >> 4));
                        d[2] = (byte)((c & 0xf) << 2);
                        if(count < x.length)
                        {
                            c = x[count];
                            count++;
                            d[2] = (byte)(d[2] + ((c & 0xc0) >> 6));
                            d[3] = (byte)(c & 0x3f);
                        } else
                        {
                            d[3] = 64;
                        }
                    } else
                    {
                        d[2] = 64;
                        d[3] = 64;
                    }
                    int n = 0;
                    while(n <= 3)
                    {
                        o.write(TableBase64.charAt(d[n]));
                        n++;
                    }
                }

            }
            catch(StringIndexOutOfBoundsException e)
            {
                FError = String.valueOf(String.valueOf(FError)) + String.valueOf(String.valueOf(e.toString()));
                System.out.println(e.toString());
            }
            return o.toString();
        }
    }