使用 ObjectStreams 与 ByteArrayStreams 进行对象序列化

Question

我已经用

为 Serialize/De-serialize java 对象编写了代码

FileOutputStream/ObjectOutputStream & FileInputStream/ObjectInputStream

VS

FileOutputStream/ByteArrayOutputStream & FileInputStream/ByteArrayInputStream

import java.io.*;  

class ObjectData implements Serializable{
    private int id;
    private String name;
    private String city;
    private int dimensions[]; 

    public ObjectData(int size){
        this.id = 1;
        this.name="ravindra";
        this.city = "Newjersey";
        this.dimensions = new int[size];
        for (int i=0;i<size;i++){
            this.dimensions[i] = i;
        }
    }
    public String toString(){
        StringBuffer sb = new StringBuffer(dimensions.length);
        sb.append("ID:NAME:CITY:DIM:").append(id).append(":").append(name).append(":");
        sb.append(city).append(":").append(dimensions.length);
        return sb.toString();
    }
}

public class ObjectSize{
    public static void main(String args[]){
        if (args.length < 1){
            System.out.println("Usage: java ObjectSize intSize");
            return;
        }
        int size = Integer.parseInt(args[0]);
        ObjectData data = new ObjectData(size);

        // Writing object with ObjectOutputStream as Object
        try{
            long t1 = System.currentTimeMillis();
            FileOutputStream fos1 = new FileOutputStream("data1.txt");  
            ObjectOutputStream out1 = new ObjectOutputStream(fos1);
            out1.writeObject(data);
            out1.close();
            fos1.close();
            long t2 = System.currentTimeMillis();
            System.out.println("Write Object Data1 with OOS in Millis:"+(t2-t1));

            t1 = System.currentTimeMillis();
            FileInputStream fis1 = new FileInputStream("data1.txt");
            ObjectInputStream ois1 = new ObjectInputStream(fis1);   
            ObjectData data1 = (ObjectData)ois1.readObject();
            System.out.println("Read Object Data1 from OIS:"+data1);
            ois1.close();
            fis1.close();
            t2 = System.currentTimeMillis();
            System.out.println("Read Object Data1 with OIS in Millis:"+(t2-t1));

        }catch(Exception err1){
            err1.printStackTrace();
        }

        try{
            long t1 = System.currentTimeMillis();
            ByteArrayOutputStream bos2 = new ByteArrayOutputStream();
            ObjectOutputStream oos2 = new ObjectOutputStream(bos2);
            oos2.writeObject(data);
            FileOutputStream fos2 = new FileOutputStream("data2.txt");
            fos2.write(bos2.toByteArray());

            /* Close resources */
            oos2.close();
            fos2.close();
            long t2 = System.currentTimeMillis();
            System.out.println("Write Object Data2 with ByteStreams in Millis:"+(t2-t1));

            t1 = System.currentTimeMillis();
            File file2 = new File("data2.txt");
            FileInputStream fis2 = new FileInputStream(file2);
            byte fileContent[] = new byte[(int)file2.length()];
            fis2.read(fileContent);
            ByteArrayInputStream bis2 = new ByteArrayInputStream(fileContent);
            /* Below two lines to be corrected */
            ObjectInputStream ois2 = new ObjectInputStream(bis2);
            ObjectData data2 = (ObjectData) ois2.readObject();

            /* Close resources */
            ois2.close();
            fis2.close();
            System.out.println("Read Object Data2 from BIS:"+data2);
            t2 = System.currentTimeMillis();
            System.out.println("Read Object Data2 with ByteStreams in Millis:"+(t2-t1));
        }catch(Exception err){
            err.printStackTrace();
        }

    }
}

我做了这个练习，因为一些用户面临使用 ObjectOutputStream 序列化大对象的问题。通过从 ObjectOutputStream 移动到 ByteArrayOutputStream，他们已经解决了这个问题。

参考文章：

http://www.javamex.com/tutorials/io/StreamCorruptedException.shtml Java StreamCorruptedException when sending object containing byte data over a certain size

我程序的输出：

D:\Study\Java>java ObjectSize 100000000
Write Object Data1 with OOS in Millis:1497
Read Object Data1 from OIS:ID:NAME:CITY:DIM:1:ravindra:Newjersey:100000000
Read Object Data1 with OIS in Millis:1202
Write Object Data2 with ByteStreams in Millis:2451
Read Object Data2 from BIS:ID:NAME:CITY:DIM:1:ravindra:Newjersey:100000000
Read Object Data2 with ByteStreams in Millis:780

D:\Study\Java>java ObjectSize 100000000
Write Object Data1 with OOS in Millis:1545
Read Object Data1 from OIS:ID:NAME:CITY:DIM:1:ravindra:Newjersey:100000000
Read Object Data1 with OIS in Millis:1185
Write Object Data2 with ByteStreams in Millis:2611
Read Object Data2 from BIS:ID:NAME:CITY:DIM:1:ravindra:Newjersey:100000000
Read Object Data2 with ByteStreams in Millis:780

D:\Study\Java>java ObjectSize 100000000
Write Object Data1 with OOS in Millis:1529
Read Object Data1 from OIS:ID:NAME:CITY:DIM:1:ravindra:Newjersey:100000000
Read Object Data1 with OIS in Millis:1203
Write Object Data2 with ByteStreams in Millis:2387
Read Object Data2 from BIS:ID:NAME:CITY:DIM:1:ravindra:Newjersey:100000000
Read Object Data2 with ByteStreams in Millis:780

D:\Study\Java>dir data*.txt
 Volume in drive D is New Volume
 Volume Serial Number is 6268-2397

 Directory of D:\Study\Java

10/21/2015  10:32 PM       400,000,144 data1.txt
10/21/2015  10:32 PM       400,000,144 data2.txt
               2 File(s)    800,000,288 bytes
               0 Dir(s)  248,054,890,496 bytes free

经过这次练习，我发现：

ObjectStreams 的写操作速度比 ByteStreams 快
ByteStreams更适合发送大对象（来自以上两篇文章）
使用 ObjectStreams 写入速度更快，使用 ByteStreams 读取速度更快。

但为什么 ByteStreams 与 ObjectStreams 相比，写入操作比读取操作花费更多时间？有没有更好的方法来提高性能？

注意：data1.txt 是用 ObjectStreams 编写的，data2.txt 是用 ByteStreams 编写的。

Answer 1

没有'object stream versus byte array stream'关于这些的任何内容。

ObjectStreams are working faster than ByteStreams for write operation

不，他们不是。通过 FileOutputStream 直接写入文件比写入 ByteArrayOutputStream 然后将其写入文件更快，这是可以预料的。为什么你会做后者是一个谜。只能浪费时间和space.

2) ByteStreams are better to send large Objects ( from above two articles)

垃圾。如果文章真的这么说，那它们也是垃圾，但我不会浪费时间阅读它们来找出答案。

3) Write is faster with ObjectStreams & Read is faster with ByteStreams

又是垃圾。您不能将对象写入字节流。您只能将它们写入对象流。您不是在将它们相互比较，而是在比较直接与间接写入文件，当然直接获胜。为什么不呢？

But why ByteStreams are taking more time compared to ObjectStreams for write operation

因为它们增加了延迟。

unlike read operation?

又一个谬论。您在这里测量的是缓冲的效果，通过在 FileInputStream 和 ObjectInputStream. 之间插入一个 BufferedInputStream 并减少浪费，您会得到类似或可能更大的改进 space.同样，FileInputStream 和 ObjectInputStream 之间的 BufferedInputStream 将提高阅读能力。

Note: data1.txt is written with ObjectStreams & data2.txt is written with ByteStreams.

同样，这完全是错误的。两者都是用对象流编写的。

使用 ObjectStreams 与 ByteArrayStreams 进行对象序列化

Object Serialization with ObjectStreams Vs ByteArrayStreams

java

serialization

inputstream

outputstream