java.io.ObjectStreamException – How to solve Object Stream Exception
In this tutorial we will discuss about ObjectStreamException
. This exception is defined as the superclass of all exceptions specific to Object Stream classes. The ObjectStreamException
is defined as an abstract class and thus, an instance of ObjectStreamException
cannot be created. Also, the ObjectStreamException
extends the IOException
class, which signals that an I/O exception has occurred.
There is a number of known sub-classes, such as InvalidObjectException
, NotSerializableException
and StreamCorruptedException
. The first exception indicates that one or more deserialized objects failed the validation tests. The second exception is thrown when an instance is required to have a Serializable
interface. The last exception is thrown when control information that was read from an object stream violates internal consistency checks. Finally, the ObjectStreamException
exists since the second version of Java (1.1).
The Structure of ObjectStreamException
Constructors
ObjectStreamException(String classname)
ObjectStreamException()
Create an ObjectStreamException
with the specified argument.
Creates an instance of the ObjectStreamException
class.
The ObjectStreamException in Java
The ObjectStreamException
class is very general and a method can use this exception, in order to enclose all its subclasses. The method can either catch the exception, or throw it to its caller method. In this tutorial we will show you A sample example that throws a ObjectStreamException
is shown below:
ObjectStreamExceptionExample.java:
import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; import java.io.ObjectStreamException; import java.util.HashMap; import java.util.Map; class SampleObject { private Map map = null; public SampleObject() { map = new HashMap(); } public void addPair(String key, String val) { map.put(key, val); } } public class ObjectStreamExceptionExample { private final static String OUTPUT_FILE = "out.txt"; public static void execute() throws FileNotFoundException, IOException { SampleObject obj = new SampleObject(); // Add some pairs into the map. obj.addPair("key1", "val1"); obj.addPair("key2", "val2"); ObjectOutputStream out = null; out = new ObjectOutputStream(new FileOutputStream(OUTPUT_FILE)); out.writeObject(obj); out.close(); //Close the stream. } public static void main(String[] args) { try { TestJava.execute(); } catch(ObjectStreamException ex) { System.err.println("An ObjectStreamException was caught!"); ex.printStackTrace(); } catch (FileNotFoundException ex) { System.err.println("A FileNotFoundException was caught!"); ex.printStackTrace(); } catch (IOException ex) { System.err.println("An IOException was caught!"); ex.printStackTrace(); } } }
In this example, we define a SampleObject
class, which contains a Map
as a private field. The SampleObject
class does not implement the Serializable
interface and thus, cannot be written to an ObjectOutputStream
. The resulting NotSerializableException
is caught inside the main method.
A sample execution is shown below:
An ObjectStreamException was caught! java.io.NotSerializableException: main.java.SampleObject at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184) at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348) at main.java.TestJava.execute(TestJava.java:37) at main.java.TestJava.main(TestJava.java:44)
This was a tutorial about the ObjectStreamException
in Java.