What's the difference between DataOutputStream and ObjectOutputStream?

I’m learning about socket programming in Java. I’ve seen client/server app examples with some using DataOutputStream, and some using ObjectOutputStream.

What’s the difference between the two?

  • Adjust Microphone Recording Volume
  • How to listen to doubletap on a view in android?
  • Why are permissions being automatically added to my AndroidManifest when including Google Play Services library
  • End animation event android
  • Method injection using Dagger 2
  • ActionBarActivity of “android-support-v7-appcompat” and ListActivity in Same activity
  • Is there a performance difference?

  • WakeLock finalized while still held
  • Right Align button in horizontal LinearLayout
  • Element must be declared error for tag shape
  • Is there an Android based Google Glass Emulator?
  • How to get thumbnail for video in my /sdcard/Android/data/mypackage/files folder?
  • Generate 10 numbers and move first number to the end 10 times
  • 4 Solutions collect form web for “What's the difference between DataOutputStream and ObjectOutputStream?”

    DataInput/OutputStream performs generally better because its much simpler. It can only read/write primtive types and Strings.

    ObjectInput/OutputStream can read/write any object type was well as primitives. It is less efficient but much easier to use if you want to send complex data.

    I would assume that the Object*Stream is the best choice until you know that its performance is an issue.

    DataOutputStream and ObjectOutputStream: when handling basic types, there is no difference apart from the header that ObjectOutputStream creates.

    With the ObjectOutputStream class, instances of a class that implements Serializable can be written to the output stream, and can be read back with ObjectInputStream.

    DataOutputStream can only handle basic types.

    This might be useful for people still looking for answers several years later… According to my tests on a recent JVM (1.8_51), the ObjectOutput/InputStream is surprisingly almost 2x times faster than DataOutput/InputStream for reading/writing a huge array of double!

    Below are the results for writing 10 million items array (for 1 million the results are the essentially the same). I also included the text format (BufferedWriter/Reader) for the sake of completeness:

    TestObjectStream written 10000000 items, took: 409ms, or 24449.8778 items/ms, filesize 80390629b
    TestDataStream written 10000000 items, took: 727ms, or 13755.1582 items/ms, filesize 80000000b
    TestBufferedWriter written 10000000 items, took: 13700ms, or 729.9270 items/ms, filesize 224486395b
    

    Reading:

    TestObjectStream read 10000000 items, took: 250ms, or 40000.0000 items/ms, filesize 80390629b
    TestDataStream read 10000000 items, took: 424ms, or 23584.9057 items/ms, filesize 80000000b
    TestBufferedWriter read 10000000 items, took: 6298ms, or 1587.8057 items/ms, filesize 224486395b
    

    I believe Oracle has heavily optimized the JVM for using ObjectStreams in last Java releases, as this is the most common way of writing/reading data (including serialization), and thus is located on the Java performance critical path.

    So looks like today there’s no much reason anymore to use DataStreams. “Don’t try to outsmart JVM”, just use the most straightforward way, which is ObjectStreams 🙂

    Here’s the code for the test:

    class Generator {
        private int seed = 1235436537;
        double generate(int i) {
            seed = (seed + 1235436537) % 936855463;
            return seed / (i + 1.) / 524323.;
        }
    }
    
    class Data {
        public final double[] array;
        public Data(final double[] array) {
            this.array = array;
        }
    }
    
    class TestObjectStream {
        public void write(File dest, Data data) {
            try (ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(dest)))) {
                for (int i = 0; i < data.array.length; i++) {
                    out.writeDouble(data.array[i]);
                }
            } catch (IOException e) {
                throw new RuntimeIoException(e);
            }
        }
        public void read(File dest, Data data) {
            try (ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(new FileInputStream(dest)))) {
                for (int i = 0; i < data.array.length; i++) {
                    data.array[i] = in.readDouble();
                }
            } catch (IOException e) {
                throw new RuntimeIoException(e);
            }
        }
    }
    
    class TestDataStream {
        public void write(File dest, Data data) {
            try (DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(dest)))) {
                for (int i = 0; i < data.array.length; i++) {
                    out.writeDouble(data.array[i]);
                }
            } catch (IOException e) {
                throw new RuntimeIoException(e);
            }
        }
        public void read(File dest, Data data) {
            try (DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(dest)))) {
                for (int i = 0; i < data.array.length; i++) {
                    data.array[i] = in.readDouble();
                }
            } catch (IOException e) {
                throw new RuntimeIoException(e);
            }
        }
    }
    
    class TestBufferedWriter {
        public void write(File dest, Data data) {
            try (BufferedWriter out = new BufferedWriter(new FileWriter(dest))) {
                for (int i = 0; i < data.array.length; i++) {
                    out.write(Double.toString(data.array[i]));
                    out.newLine();
                }
            } catch (IOException e) {
                throw new RuntimeIoException(e);
            }
        }
        public void read(File dest, Data data) {
            try (BufferedReader in = new BufferedReader(new FileReader(dest))) {
                String line = in.readLine();
                int i = 0;
                while (line != null) {
                    if(!line.isEmpty()) {
                        data.array[i++] = Double.parseDouble(line);
                    }
                    line = in.readLine();
                }
            } catch (IOException e) {
                throw new RuntimeIoException(e);
            }
        }
    }
    
    @Test
    public void testWrite() throws Exception {
        int N = 10000000;
        double[] array = new double[N];
        Generator gen = new Generator();
        for (int i = 0; i < array.length; i++) {
            array[i] = gen.generate(i);
        }
        Data data = new Data(array);
    
        Map<Class, BiConsumer<File, Data>> subjects = new LinkedHashMap<>();
        subjects.put(TestDataStream.class, new TestDataStream()::write);
        subjects.put(TestObjectStream.class, new TestObjectStream()::write);
        subjects.put(TestBufferedWriter.class, new TestBufferedWriter()::write);
    
        subjects.forEach((aClass, fileDataBiConsumer) -> {
    
            File f = new File("test." + aClass.getName());
    
            long start = System.nanoTime();
            fileDataBiConsumer.accept(f, data);
            long took = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
    
            System.out.println(aClass.getSimpleName() + " written " + N + " items, took: " + took + "ms, or " + String.format("%.4f", (N / (double)took)) + " items/ms, filesize " + f.length() + "b");
        });
    }
    
    
    @Test
    public void testRead() throws Exception {
        int N = 10000000;
        double[] array = new double[N];
        Data data = new Data(array);
    
        Map<Class, BiConsumer<File, Data>> subjects = new LinkedHashMap<>();
        subjects.put(TestDataStream.class, new TestDataStream()::read);
        subjects.put(TestObjectStream.class, new TestObjectStream()::read);
        subjects.put(TestBufferedWriter.class, new TestBufferedWriter()::read);
    
        subjects.forEach((aClass, fileDataBiConsumer) -> {
            File f = new File("test." + aClass.getName());
    
            long start = System.nanoTime();
            fileDataBiConsumer.accept(f, data);
            long took = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
    
            System.out.println(aClass.getSimpleName() + " read " + N + " items, took: " + took + "ms, or " + String.format("%.4f", (N / (double)took)) + " items/ms, filesize " + f.length() + "b");
        });
    }
    

    Only objects that implement the java.io.Serializable interface can be written to streams using ObjectOutputStream.Primitive data types can also be written to the stream using the appropriate methods from DataOutput. Strings can also be written using the writeUTF method. But DataInputStream on the other hand lets an application write primitive Java data types to an output stream in a portable way.

    Object OutputStream

    Data Input Stream

    Android Babe is a Google Android Fan, All about Android Phones, Android Wear, Android Dev and Android Games Apps and so on.