Object streams, like data streams, allow for the I\/O of primitive data types. Most, but not all, standard classes enable their objects to be serialized. Those that do implement the Serializable marker interface.<\/p>\n
ObjectInputStream and ObjectOutputStream are the object stream classes. These classes implement ObjectInput and ObjectOutput, which are DataInput and DataOutput subinterfaces.<\/p>\n
That is, all of the primitive data I\/O methods covered in Data Streams are also implemented in object streams. As a result, an object stream can contain both primitive and object values. This is demonstrated by the ObjectStreams example.<\/p>\n
With a few exceptions, ObjectStreams creates the same application as DataStreams. To begin with, prices are now BigDecimalobjects to represent fractional values better. Then, a Calendar object is written in the data file.<\/p>\n
The writeObject and readObject methods are simple to use, but they contain complex object management logic. This is unimportant for a class like Calendar, which only holds primitive values.<\/p>\n
Many objects, however, contain references to other objects. If readObject is to recreate an object from a stream, it must be able to recreate all the objects to which the original object referred.<\/p>\n
These additional objects may have their references, for example. WriteObject traverses the entire web of object references and writes all objects in that web to the stream.<\/p>\n
As a result, a single call to writeObject can result in many objects being written to the stream.<\/p>\n
What happens if two objects on the same stream both contain references to the same object? Will they both refer to the same object when read back? Yes, the answer is “yes.” A stream can only have one copy of an object, but it can have unlimited references to it. As a result, if you explicitly write an object to a stream twice, you’re only writing the reference twice.<\/p>\n
For instance, consider the following code, which writes an object ob twice to a stream:<\/strong><\/p>\n Object ob = new Object(); out.writeObject(ob); out.writeObject(ob); Because each writeObject must be matched by a readObject, the code that reads the stream back will look like this:<\/p>\n This yields two objects.<\/p>\n ObjectInputStream Operation The ObjectInputStream is primarily used to read data written by the ObjectOutputStream.<\/p>\n Essentially, the ObjectOutputStream converts Java objects into streams. This is referred to as serialization. These converted streams can be saved to files or transmitted over networks.<\/p>\n If we need to read those objects, we’ll use the ObjectInputStream to convert the streams back to objects. This is referred to as deserialization.<\/p>\n We must first import the java.io.ObjectInputStream package to create an object input stream. Here’s how to make an input stream after we’ve imported the package.<\/p>\n The ObjectInputStream class implements the InputStream class’s methods.<\/p>\n Method read() Output<\/strong> The writeObject and readObject methods are simple to use, but they contain complex object management logic. This is unimportant for a class like Calendar, which only holds primitive values. Many objects, however, include references to other objects. If readObject is to recreate an object from a stream, it must be able to recreate all the objects to which the original object referred. These additional objects may have their references.<\/p>\n For example. WriteObject traverses the entire web of object references and writes all objects in that web to the stream. As a result, a single call to writeObject can result in many objects being written to the stream. What happens if two objects on the same stream both contain references to the same object? Will they both refer to the same object when read back? Yes, the answer is “yes.” A stream can only have one copy of an object, but it can have unlimited references to it. As a result, if you explicitly write an object to a stream twice, you’re only writing the reference twice.<\/p>\n For instance, consider the following code, which writes an object ob twice to a stream:<\/strong><\/p>\n Object ob = new Object(); out.writeObject(ob); out.writeObject(ob); Because each writeObject must be matched by a readObject, the code that reads the stream back will look like this:<\/p>\n This yields two objects.<\/p>\n ObjectOutputStream named output using the FileOutputStream named file A Dog class object dog<\/strong><\/p>\n We then used the object output stream to write the object to the file. The object input stream is used to read the object from the file.<\/p>\n The Dog class implements the Serializable interface. This is because the ObjectOutputStream only writes serializable objects to the output stream.<\/p>\n Java streams support functional-style operations on element streams. A stream is a non-mutable collection of functions applied to data in a specific order. A stream is not a collection of elements that can be stored.<\/p>\n","protected":false},"excerpt":{"rendered":" Object streams, like data streams, allow for the I\/O of primitive data types. Most, but not all, standard classes enable their objects to be serialized. Those that do implement the Serializable marker interface. ObjectInputStream...<\/p>\n","protected":false},"author":6,"featured_media":447241,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[183],"tags":[296,5521,5685,263,327,250,5523,5522],"class_list":["post-89833","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-java","tag-java-objectstream-class","tag-java-objectstream-class-with-examples","tag-java-tutorial-for-beginners","tag-java-tutorials","tag-learn-java","tag-objectstream-class","tag-objectstream-class-in-java"],"yoast_head":"\nObject ob1 = in.readObject(); Object ob2 = in.readObject();<\/pre>\n
Construct an ObjectInputStream:<\/h3>\n
\/\/Creates a file input stream linked with the specified file\r\nFileInputStream fileStream = new FileInputStream(String file);\r\n\r\n\/\/ Creates an object input stream using the file input stream\r\nObjectInputStream objStream = new ObjectInputStream(fileStream);<\/pre>\n
ObjectInputStream methods:<\/h3>\n
\nread() returns a single byte from the input stream.
\nreadBoolean() is a function that reads boolean data.
\nreadChar() – reads data in character format.
\nreadInt() is a function that reads integer data.
\nreadObject() is a function that retrieves an object from the input stream.<\/p>\nExample:<\/h4>\n
import java.io.ObjectStreamClass;\r\nimport java.util.Calendar;\r\npublic class TechVidvan{\r\n public static void main(String[] args) {\r\n ObjectStreamClass osc = ObjectStreamClass.lookup(String.class); System.out.println(\"String in TechVidvan: \" + osc.getField(\"class\"));\r\n ObjectStreamClass osc2 = ObjectStreamClass.lookup(Calendar.class);\r\n System.out.println(\"Calendar in TechVidvan: \" + osc2.getField(\"class\"));\r\n }\r\n}<\/pre>\n
\nString in TechVidvan:<\/strong> null
\nCalendar in TechVidvan:<\/strong> null<\/p>\nComplex Object Output and Input<\/h3>\n
Object ob1 = in.readObject(); Object ob2 = in.readObject();<\/pre>\n
\nObjectInputStream named input using the FileInputStream named fileStream<\/p>\nConclusion<\/h3>\n