Java.io.ObjectOutputStream Class in Java | Set 2 Last Updated : 12 Sep, 2023 Comments Improve Suggest changes Like Article Like Report Java.io.ObjectOutputStream Class in Java | Set 1 More Methods: void write(byte[] buf) : Writes an array of bytes. This method will block until the byte is actually written. Syntax :public void write(byte[] buf) throws IOException Parameters: buf - the data to be written Throws: IOException void write(byte[] buf, int off, int len) : Writes a sub array of bytes. Syntax :public void write(byte[] buf, int off, int len) throws IOException Parameters: buf - the data to be written off - the start offset in the data len - the number of bytes that are written Throws: IOException void write(int val) : Writes a byte. This method will block until the byte is actually written. Syntax :public void write(int val) throws IOException Parameters: val - the byte to be written to the stream Throws: IOException void writeBoolean(boolean val) : Writes a boolean. Syntax :public void writeBoolean(boolean val) throws IOException Parameters: val - the boolean to be written Throws: IOException void writeByte(int val) : Writes an 8 bit byte. Syntax :public void writeByte(int val) throws IOException Parameters: val - the byte value to be written Throws: IOException void writeBytes(String str) : Writes a String as a sequence of bytes. Syntax :public void writeBytes(String str) throws IOException Parameters: str - the String of writeBytes to be written Throws: IOException void writeChar(int val) : Writes a 16 bit char. Syntax :public void writeChar(int val) throws IOException Parameters: val - the char value to be written Throws: IOException void writeChars(String str) : Writes a String as a sequence of chars. Syntax :public void writeChars(String str) throws IOException Parameters: str - the String of chars to be written Throws: IOException protected void writeClassDescriptor(ObjectStreamClass desc) : Write the specified class descriptor to the ObjectOutputStream. Class descriptors are used to identify the classes of objects written to the stream. Subclasses of ObjectOutputStream may override this method to customize the way in which class descriptors are written to the serialization stream. The corresponding method in ObjectInputStream, readClassDescriptor, should then be overridden to reconstitute the class descriptor from its custom stream representation. By default, this method writes class descriptors according to the format defined in the Object Serialization specification. Syntax :protected void writeClassDescriptor(ObjectStreamClass desc) throws IOException Parameters: desc - class descriptor to write to the stream Throws: IOException void writeDouble(double val) : Writes a 64 bit double. Syntax :public void writeDouble(double val) throws IOException Parameters: val - the double value to be written Throws: IOException void writeFields() : Write the buffered fields to the stream. Syntax :public void writeFields() throws IOException Throws: IOException NotActiveException void writeFloat(float val) : Writes a 32 bit float. Syntax :public void writeFloat(float val) throws IOException Parameters: val - the float value to be written Throws: IOException void writeInt(int val) : Writes a 32 bit int. Syntax :public void writeInt(int val) throws IOException Parameters: val - the integer value to be written Throws: IOException void writeLong(long val) : Writes a 64 bit long. Syntax :public void writeLong(long val) throws IOException Parameters: val - the long value to be written Throws: IOException void writeObject(Object obj) : Write the specified object to the ObjectOutputStream.The class of the object, the signature of the class, and the values of the non-transient and non-static fields of the class and all of its supertypes are written. Default serialization for a class can be overridden using the writeObject and the readObject methods. Objects referenced by this object are written transitively so that a complete equivalent graph of objects can be reconstructed by an ObjectInputStream. Syntax :public final void writeObject(Object obj) throws IOException Parameters: obj - the object to be written Throws: InvalidClassException NotSerializableException IOException protected void writeObjectOverride(Object obj) : Method used by subclasses to override the default writeObject method. This method is called by trusted subclasses of ObjectInputStream that constructed ObjectInputStream using the protected no-arg constructor. The subclass is expected to provide an override method with the modifier "final". Syntax :protected void writeObjectOverride(Object obj) throws IOException Parameters: obj - object to be written to the underlying stream Throws: IOException void writeShort(int val) : Writes a 16 bit short. Syntax :public void writeShort(int val) throws IOException Parameters: val - the short value to be written Throws: IOException protected void writeStreamHeader() : The writeStreamHeader method is provided so subclasses can append or prepend their own header to the stream.It writes the magic number and version to the stream. Syntax :protected void writeStreamHeader() throws IOException Throws: IOException void writeUnshared(Object obj) : Writes an "unshared" object to the ObjectOutputStream. This method is identical to writeObject, except that it always writes the given object as a new, unique object in the stream (as opposed to a back-reference pointing to a previously serialized instance). Specifically: An object written via writeUnshared is always serialized in the same manner as a newly appearing object (an object that has not been written to the stream yet), regardless of whether or not the object has been written previously. If writeObject is used to write an object that has been previously written with writeUnshared, the previous writeUnshared operation is treated as if it were a write of a separate object. In other words, ObjectOutputStream will never generate back-references to object data written by calls to writeUnshared. While writing an object via writeUnshared does not in itself guarantee a unique reference to the object when it is deserialized, it allows a single object to be defined multiple times in a stream, so that multiple calls to readUnshared by the receiver will not conflict. Note that the rules described above only apply to the base-level object written with writeUnshared, and not to any transitively referenced sub-objects in the object graph to be serialized. ObjectOutputStream subclasses which override this method can only be constructed in security contexts possessing the "enableSubclassImplementation" SerializablePermission; any attempt to instantiate such a subclass without this permission will cause a SecurityException to be thrown. Syntax :public void writeUnshared(Object obj) throws IOException Parameters: obj - object to write to stream Throws: NotSerializableException InvalidClassException IOException void writeUTF(String str) : Primitive data write of this String in modified UTF-8 format.Note that there is a significant difference between writing a String into the stream as primitive data or as an Object. A String instance written by writeObject is written into the stream as a String initially. Future writeObject() calls write references to the string into the stream. Syntax :public void writeUTF(String str) throws IOException Parameters: str - the String to be written Throws: IOException void flush() :Flushes the stream. This will write any buffered output bytes and flush through to the underlying stream. Syntax :public void flush() throws IOException Throws: IOException Program : Java //Java program demonstrating ObjectOutputStream //write methods import java.io.*; class ObjectOutputStreamDemo { public static void main(String[] args) throws IOException, ClassNotFoundException { FileOutputStream fout = new FileOutputStream("file.txt"); ObjectOutputStream oot = new ObjectOutputStream(fout); String a = "GeeksforGeeks"; String b = "Geek"; byte[] be = {'A','B','C'}; //illustrating write() oot.write(1); //illustrating writeInt(int i) oot.writeInt(1); //illustrating writeBoolean(boolean a) oot.writeBoolean(true); //illustrating writeObject(Object x) oot.writeObject(a); //illustrating writeByte(byte a) oot.writeByte(65); //illustrating writeBytes(String b) oot.writeBytes(b); //illustrating writeDouble(double d) oot.writeDouble(2.3); //illustrating writeUTF(String str) oot.writeUTF(a); //illustrating writeFloat(float x) oot.writeFloat(2.42f); //illustrating writeLone(long x) oot.writeLong(234342347908l); //illustrating writeChars(String a) oot.writeChars(a); //illustrating writeShort(int val) oot.writeShort(2); //illustrating write(byte[] buff) oot.write(be); //flushing the stream oot.flush(); oot.close(); byte c[]=new byte[4]; char c1[]=new char[13]; FileInputStream fin = new FileInputStream("file.txt"); ObjectInputStream oit = new ObjectInputStream(fin); System.out.println(oit.read()); System.out.println(oit.readInt()); System.out.println(oit.readBoolean()); System.out.println(oit.readObject()); System.out.println(oit.readByte()); oit.read(c); for (int i = 0; i < 4 ; i++) { System.out.print((char)c[i]); } System.out.println(); System.out.println(oit.readDouble()); System.out.println(oit.readUTF()); System.out.println(oit.readFloat()); System.out.println(oit.readLong()); for (int i = 0; i < 13 ; i++) { System.out.print(oit.readChar()); } System.out.println(); System.out.println(oit.readShort()); oit.readFully(be); for (int i = 0; i < 3 ; i++) { System.out.print((char)be[i]); } oit.close(); } } Output : 1 1 true GeeksforGeeks 65 Geek 2.3 GeeksforGeeks 2.42 234342347908 GeeksforGeeks 2 ABC Program 2: Java //Java program illustrating ObjectOutputStream //write methods import java.io.*; class ObjectOutputStreamDemo { public static void main(String[] args) throws IOException, ClassNotFoundException { FileOutputStream out = new FileOutputStream("file.txt"); ObjectOutputStream oout = new ObjectOutputStream(out); oout.writeObject(new demo()); //illustrating writeUnshared() //Writes an "unshared" object to the ObjectOutputStream. oout.writeUnshared(14); //flush the stream oout.flush(); oout.close(); FileInputStream fin=new FileInputStream("file.txt"); ObjectInputStream ois=new ObjectInputStream(fin); // read an object from the stream and cast it to demo demo obj = (demo)ois.readObject(); System.out.println( obj.var); System.out.println(ois.readUnshared()); } } class demo implements Serializable { static int var = 25; // assign a new serialPersistentFields private static final ObjectStreamField[] serialPersistentFields = { new ObjectStreamField("var", Integer.TYPE) }; private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { // makes them available by name. ObjectInputStream.GetField fields = in.readFields(); //Get the value of the named int field from the persistent field. var = fields.get("var", 0); } private void writeObject(ObjectOutputStream out) throws IOException { // write into the ObjectStreamField array the variable string ObjectOutputStream.PutField fields = out.putFields(); fields.put("var", var); //Write the buffered fields to the stream out.writeFields(); } } Output : 25 14 Comment More infoAdvertise with us Next Article Java.io.ObjectOutputStream Class in Java | Set 2 N Nishant Sharma Improve Article Tags : Advance Java Similar Reads Java.io.ObjectInputStream Class in Java | Set 1 ObjectInputStream Class deserializes the primitive data and objects previously written by ObjectOutputStream. Both ObjectOutputStream and ObjectInputStream are used as it provides storage for graphs of object.It ensures that the object it is working for, matches the classes of JVM i.e Java Virtual M 9 min read Java.io.ObjectInputStream Class in Java | Set 2 Java.io.ObjectInputStream Class in Java | Set 1 Note : Java codes mentioned in this article won't run on Online IDE as the file used in the code doesn't exists online. So, to verify the working of the codes, you can copy them to your System and can run it over there. More Methods of ObjectInputStrea 6 min read Java.io.ObjectOutputStream Class in Java | Set 1 An ObjectOutputStream writes primitive data types and graphs of Java objects to an OutputStream. The objects can be read (reconstituted) using an ObjectInputStream. Persistent storage of objects can be accomplished by using a file for the stream. Only objects that support the java.io.Serializable in 9 min read Java.io.OutputStream class in Java This abstract class is the superclass of all classes representing an output stream of bytes. An output stream accepts output bytes and sends them to some sink. Applications that need to define a subclass of OutputStream must always provide at least a method that writes one byte of output. Constructo 2 min read Java.io.InputStream Class in Java Java InputStream class is the superclass of all the io classes i.e. representing an input stream of bytes. It represents an input stream of bytes. Applications that are defining a subclass of the Java InputStream class must provide a method, that returns the next byte of input. A reset() method is i 3 min read Java.io.DataOutputStream in Java A data output stream lets an application write primitive Java data types to an output stream in a portable way. An application can then use a data input stream to read the data back in. Let us do discuss the constructor of this class prior to moving ahead to the methods of this class. Constructor: 5 min read ObjectInputStream available() method in Java with examples The available() method of the ObjectInputStream class in Java returns the number of bytes that can be read without blocking the stream. Syntax: public int available() Parameters: This method does not accept any parameter. Return Value: This method returns the number of available bytes. Below program 1 min read ObjectInputStream read() method in Java with examples The read() method of the ObjectInputStream class in Java reads a byte of data. This method wont run if there is no data. Syntax: public int read() Parameters: This method does not accept any parameter. Return Value: This method returns the byte read, or -1 if the end of the stream is reached. Except 1 min read How to Fix java.io.StreamCorruptedException: invalid type code in Java? There are several problems been faced which are as follows: When you write an object in a file using serialization in java for the first time, no problem arises in reading the file afterward, even when you write multiple objects in one go.Now, when next time you try to append new objects (of the sam 6 min read Java.io.BufferedInputStream class in Java A BufferedInputStream adds functionality to another input stream-namely, the ability to buffer the input and to support the mark and reset methods. When the BufferedInputStream is created, an internal buffer array is created. As bytes from the stream are read or skipped, the internal buffer is refil 4 min read Like