Question

我编写了使用

序列化/反序列化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＆amp;使用ByteStreams可以更快地读取。

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

注意：data1.txt是用ObjectStreams＆amp;写的。 data2.txt是用ByteStreams编写的。

Answer 1

没有关于任何此类的“对象流与字节数组流”。

ObjectStreams比ByteStreams更快地进行写入操作

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

2）ByteStreams最好发送大型对象（来自上面两篇文章）

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

3）使用ObjectStreams＆amp;使用ByteStreams读取速度更快

再次垃圾。您不能将对象写入字节流。您只能将它们写入对象流。你不是要将这些相互比较，而是将与直接间接写入文件，当然还有直接获胜。为什么不呢？

但是为什么ByteStreams比ObjectStreams花费更多时间进行写操作

因为它们会增加延迟。

与读操作不同？

另一个谬误。你在这里测量的是缓冲的效果，你可以通过在BufferedInputStream和FileInputStream之间插入ObjectInputStream.来获得类似或可能更大的改进，并浪费更少的空间。同样，BufferedInputStream和FileInputStream之间的ObjectInputStream会提高阅读效果。

注意：data1.txt是用ObjectStreams＆amp;写的。 data2.txt是用ByteStreams编写的。

同样，这完全是不真实的。两者都是用对象流编写的。

使用ObjectStreams对象序列化与ByteArrayStreams对比

1 个答案: