ObjectOutputStream (GNU Classpath 0.94-pre Documentation)

An ObjectOutputStream can be used to write objects as well as primitive data in a platform-independent manner to an OutputStream. The data produced by an ObjectOutputStream can be read and reconstituted by an ObjectInputStream. writeObject (Object) is used to write Objects, the write<type> methods are used to write primitive data (as in DataOutputStream). Strings can be written as objects or as primitive data. Not all objects can be written out using an ObjectOutputStream. Only those objects that are an instance of java.io.Serializable can be written. Using default serialization, information about the class of an object is written, all of the non-transient, non-static fields of the object are written, if any of these fields are objects, they are written out in the same manner. An object is only written out the first time it is encountered. If the object is encountered later, a reference to it is written to the underlying stream. Thus writing circular object graphs does not present a problem, nor are relationships between objects in a graph lost. Example usage:

 Hashtable map = new Hashtable ();
 map.put ("one", new Integer (1));
 map.put ("two", new Integer (2));

 ObjectOutputStream oos =
 new ObjectOutputStream (new FileOutputStream ("numbers"));
 oos.writeObject (map);
 oos.close ();

 ObjectInputStream ois =
 new ObjectInputStream (new FileInputStream ("numbers"));
 Hashtable newmap = (Hashtable)ois.readObject ();

 System.out.println (newmap);

The default serialization can be overriden in two ways. By defining a method

private void
 writeObject (ObjectOutputStream)

, a class can dictate exactly how information about itself is written. defaultWriteObject () may be called from this method to carry out default serialization. This method is not responsible for dealing with fields of super-classes or subclasses. By implementing java.io.Externalizable. This gives the class complete control over the way it is written to the stream. If this approach is used the burden of writing superclass and subclass data is transfered to the class implementing java.io.Externalizable.

Nested Class Summary
abstract static class	ObjectOutputStream.PutField This class allows a class to specify exactly which fields should be written, and what values should be written for these fields.

Constructor Summary
	ObjectOutputStream(OutputStream out) Creates a new `ObjectOutputStream` that will do all of its writing onto `out`.
protected	ObjectOutputStream() Protected constructor that allows subclasses to override serialization.

Method Summary
protected void	annotateClass(Class<?> cl) An empty hook that allows subclasses to write extra information about classes to the stream.
protected void	annotateProxyClass(Class<?> cl)
void	close()
void	defaultWriteObject() Writes the current objects non-transient, non-static fields from the current class to the underlying output stream.
protected void	drain() Causes the block-data buffer to be written to the underlying stream, but does not flush underlying stream.
protected boolean	enableReplaceObject(boolean enable) If `enable` is `true` and this object is trusted, then `replaceObject (Object)` will be called in subsequent calls to `writeObject (Object)`.
void	flush()
ObjectOutputStream.PutField	putFields()
protected Object	replaceObject(Object obj) Allows subclasses to replace objects that are written to the stream with other objects to be written in their place.
void	reset() Resets stream to state equivalent to the state just after it was constructed.
void	useProtocolVersion(int version) Informs this `ObjectOutputStream` to write data according to the specified protocol.
void	write(int data)
void	write(byte[] b)
void	write(byte[] b, int off, int len)
void	writeBoolean(boolean data)
void	writeByte(int data)
void	writeBytes(String data)
void	writeChar(int data)
void	writeChars(String data)
protected void	writeClassDescriptor(ObjectStreamClass osc)
void	writeDouble(double data)
void	writeFields()
void	writeFloat(float data)
void	writeInt(int data)
void	writeLong(long data)
void	writeObject(Object obj) Writes a representation of `obj` to the underlying output stream by writing out information about its class, then writing out each of the objects non-transient, non-static fields.
protected void	writeObjectOverride(Object obj) This method allows subclasses to override the default serialization mechanism provided by `ObjectOutputStream`.
void	writeShort(int data)
protected void	writeStreamHeader() Writes stream magic and stream version information to the underlying stream.
void	writeUnshared(Object obj) Writes an object to the stream in the same manner as {@link #writeObject(Object)}, but without the use of references.
void	writeUTF(String data)

Constructor Detail

ObjectOutputStream

Protected constructor that allows subclasses to override serialization. This constructor should be called by subclasses that wish to override writeObject (Object). This method does a security check NOTE: currently not implemented, then sets a flag that informs writeObject (Object) to call the subclasses writeObjectOverride (Object) method.

Class ObjectOutputStream

Constructor Detail

ObjectOutputStream

ObjectOutputStream

Method Detail

annotateClass

annotateProxyClass

close

defaultWriteObject

drain

enableReplaceObject

flush

putFields

replaceObject

reset

useProtocolVersion

write

write

write

writeBoolean

writeByte

writeBytes

writeChar

writeChars

writeClassDescriptor

writeDouble

writeFields

writeFloat

writeInt

writeLong

writeObject

writeObjectOverride

writeShort

writeStreamHeader

writeUnshared

writeUTF