ObjectInput/OutputStream与DataInput/OutputStream处理基本类型实例的差异

Great question! Let’s break down the key differences between how these two stream pairs handle primitive types—they might seem interchangeable at first glance, but they’re built for distinct use cases with clear behavioral gaps.

1. Core Design Purpose #

• DataInputStream/DataOutputStream are purpose-built for lightweight, raw binary I/O of Java primitives (int, float, boolean, etc.) and strings. Think of them as a no-frills tool for exchanging simple data between systems or storing values efficiently—their sole job is converting primitives to/from binary without extra baggage.
• ObjectInputStream/ObjectOutputStream are designed for serializing/deserializing full Java objects (including primitive wrapper classes like Integer or custom objects with state). They exist to preserve an object’s complete identity, including class metadata, so you can reconstruct the exact object later.

2. Serialization Format & Overhead #

This is where the most concrete differences show up:

• For raw primitives (using methods like writeInt(), writeBoolean()):
  • DataOutputStream writes only the raw binary value of the primitive. For example, an int gets written as 4 big-endian bytes—exactly how it’s stored in Java memory—no extra bytes added.
  • ObjectOutputStream implements the DataOutput interface, so its writeInt() method writes the same 4-byte value. But here’s the catch: the first time you write anything to an ObjectOutputStream, it adds a magic header (0xACED 0x0005) and version number to the stream. Even if you only write primitives, this 4-byte header is tacked on upfront. If you try to read this stream with DataInputStream, you’ll get garbage values because it doesn’t skip the header.
• For primitive wrapper objects (e.g., writing Integer.valueOf(42) via writeObject()):
  • DataOutputStream can’t handle this directly—you’d have to unwrap the object to a primitive first (like dos.writeInt(myIntObj.intValue())).
  • ObjectOutputStream will write the full serialized object: class name, serial version UID, and then the primitive value. This adds significant overhead (dozens of bytes for a single wrapper object) compared to the raw primitive write.

3. Usage Patterns & Error Handling #

• Data*Stream usage is straightforward and low-ceremony:

  // Writing raw primitives
  DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.bin"));
  dos.writeInt(123);
  dos.writeBoolean(true);
  dos.close();
  
  // Reading
  DataInputStream dis = new DataInputStream(new FileInputStream("data.bin"));
  int num = dis.readInt();
  boolean flag = dis.readBoolean();
  dis.close();
  

  You only need to handle IOException here.
• Object*Stream has more boilerplate, especially when working with objects:

  // Writing a wrapper object + raw primitive
  ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.bin"));
  oos.writeObject(Integer.valueOf(123)); // Writes full object metadata + value
  oos.writeInt(456); // Writes raw int, but stream already has the header
  oos.close();
  
  // Reading
  ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.bin"));
  Integer numObj = (Integer) ois.readObject(); // Needs casting, handles class lookup
  int rawNum = ois.readInt();
  ois.close();
  

  Here you have to handle both IOException and ClassNotFoundException (since the stream needs to find the class definition to reconstruct the object).

4. Performance & Interoperability #

• Data*Stream is faster and produces smaller output because there’s no metadata overhead. It’s also more interoperable—other programming languages can easily parse the binary format (since it’s just standard primitive representations, like big-endian integers).
• Object*Stream is slower and bulkier when dealing with objects (thanks to metadata). Its serialization format is Java-specific—you can’t easily read an object serialized with ObjectOutputStream in Python, C#, etc. Plus, if the serialized class changes (e.g., adding a field without a serialVersionUID), deserialization can fail entirely.

5. When to Use Which? #

• Go for DataInputStream/DataOutputStream if:
  • You only need to read/write raw primitives or strings.
  • You want minimal overhead and cross-language compatibility.
• Choose ObjectInputStream/ObjectOutputStream if:
  • You need to serialize/deserialize full Java objects (including wrapped primitives or custom objects with state).
  • You’re working in a Java-only environment and need to preserve object identity.

内容的提问来源于stack exchange，提问作者user10082400