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 Machine. Only those Object can be read from the streams that supports Serializable or Externalizable – IO classes, otherwise error.
  Serializable is basically a kind of marker for JVM(Java Virtual Machine) directing it to write out the state of Object present in Stream

Declaration :

public class ObjectInputStream
  extends InputStream
    implements ObjectInput, ObjectStreamConstants

Constructors :

• protected ObjectInputStream() : Help the sub-classes to not allocate private data used by ObjectInputStream, if they are re-implementing the ObjectInputStream.
• ObjectInputStream(InputStream source_input) : Create ObjectInputStream that read data from the ‘source_input’ Input Stream.

Methods:

• read() : java.io.ObjectInputStream.read() reads the byte of data and blocks in case no data is present to read.
  Syntax :

  public int read()
  Parameters : 
  -----------
  Return : 
  reads byte else, return -1 if end of Stream is detected.
  Exception :
  -> IOException : in case of any IO error occurs.
  

• readBoolean() : java.io.ObjectInputStream.readBoolean() reads in a boolean.
  Syntax :

  public int readBoolean()
  Parameters : 
  -----------
  Return : 
  reads in a boolean.
  Exception :
  -> IOException : in case of any IO error occurs.
  -> EOFException : if end of the stream is reached.
  

  
  

  
  
  

  // Java program explaining the working of read(), readBoolean() method    import java.io.*;    public class NewClass {     public static void main(String[] args) throws IOException     {         // create a new file with an ObjectOutputStream and ObjectInputStream         FileOutputStream geek_out = new FileOutputStream("GEEKS.txt");                    ObjectOutputStream geek_outStream = new ObjectOutputStream(geek_out);         ObjectInputStream Geek_inStream =                          new ObjectInputStream(new FileInputStream("GEEKS.txt"));            // Methods covered in later         geek_outStream.writeBoolean(true);         geek_outStream.writeUTF("Geeks For Geeks");         geek_outStream.flush();            // Use of readBoolean()          System.out.println("USe of readBoolean() : " + Geek_inStream.readBoolean());            System.out.print("Use of read() method in Java : ");                    // Use of read() method : reading the content of file         for (int i = 0; i < Geek_inStream.available();)         {             System.out.print((char) Geek_inStream.read());         }        } }

  Output :

  USe of readBoolean() : true
  Use of read() method in Java : Geeks For Geeks
  

• read(byte[] buffer, int offset, int maxlen) : java.io.ObjectInputStream.read(byte[] buffer, int offset, int maxlen) reads part of data from the ‘buffer’ starting from offset position upto maxlen position of the buffer.
  Syntax :

  public int read(byte[] buffer, int offset, int maxlen)
  Parameters : 
  buffer : buffer to be read
  offset : starting position of the buffer
  maxlen : max. no. of bytes to be read
  Return : 
  reads 'maxlen' bytes of data else, return -1 if end of Stream is detected.
  Exception :
  -> IOException : in case of any IO error occurs.
  

  
  

  
  
  

  // Java program explaining the working of // read(byte[] buffer, int offset, int maxlen)    import java.io.*;    public class NewClass {     public static void main(String[] args) throws IOException     {         // create a new file with an ObjectOutputStream and ObjectInputStream         FileOutputStream geek_out = new FileOutputStream("GEEKS.txt");                    ObjectOutputStream geek_outStream = new ObjectOutputStream(geek_out);                    // create an ObjectInputStream for the file we created before         ObjectInputStream Geek_inStream             = new ObjectInputStream(new FileInputStream("GEEKS.txt"));               geek_outStream.writeUTF("GeeksForGeeks");         geek_outStream.flush();            byte[] buffer = new byte[25];            // Use of read(byte[] buffer, int offset, int maxlen)         Geek_inStream.read(buffer, 2, 20);            System.out.print("Use of read(buffer, offset, maxlen) : ");         for (int i = 0; i < 19; i++)         {             System.out.print((char)buffer[i]);         }     } }

  Output :

  GeeksForGeeks

• readByte() : java.io.ObjectInputStream.readByte() reads 8-bit byte.
  Syntax :

  public byte readByte()
  Parameters : 
  -----------
  Return : 
  reads 8-bit byte.
  Exception :
  -> IOException : in case of any IO error occurs.
  -> EOFException : if end of the stream is reached.
  

• readChar() : java.io.ObjectInputStream.readChar() reads 16-bit of char.
  Syntax :

  public int read()
  Parameters : 
  -----------
  Return : 
  reads 16-bit of char.
  Exception :
  -> IOException : in case of any IO error occurs.
  -> EOFException : if end of the stream is reached.
  

• readDouble() : java.io.ObjectInputStream.readDouble() reads 64 bit double.
  Syntax :
  
  
  
  

  public double readDouble()
  Parameters : 
  -----------
  Return : 
  reads 64 bit double.
  Exception :
  -> IOException : in case of any IO error occurs.
  -> EOFException : if end of the stream is reached.
  

• readFloat() : java.io.ObjectInputStream.readFloat() reads a 32 bit float.
  Syntax :

  public float readFloat()
  Parameters : 
  -----------
  Return : 
  reads a 32 bit float.
  Exception :
  -> IOException : in case of any IO error occurs.
  -> EOFException : if end of the stream is reached.
  

• readInt() : java.io.ObjectInputStream.readInt() reads a 32 bit int.
  Syntax :

  public int readInt()
  Parameters : 
  -----------
  Return : 
  reads a 32 bit int.
  Exception :
  -> IOException : in case of any IO error occurs.
  -> EOFException : if end of the stream is reached.
  

• readLong() : java.io.ObjectInputStream.readLong() reads a 64 bit long.
  Syntax :

  public long readLong()
  Parameters : 
  -----------
  Return : 
  reads a 64 bit long.
  Exception :
  -> IOException : in case of any IO error occurs.
  -> EOFException : if end of the stream is reached.
  

  
  

  
  
  

  // Java program explaining the working of // readChar(), writeByte(), writeDouble(), // writeFloat(), writeInt(), writeLong()    import java.io.*;    public class NewClass {     public static void main(String[] args) throws IOException     {         // create a new file with an ObjectOutputStream and ObjectInputStream         FileOutputStream geek_out = new FileOutputStream("GEEKS.txt");         ObjectOutputStream geek_outStream = new ObjectOutputStream(geek_out);                    // create an ObjectInputStream for the file we created before         ObjectInputStream Geek_inStream                      = new ObjectInputStream(new FileInputStream("GEEKS.txt"));               geek_outStream.writeChar('G');         geek_outStream.writeByte('G');         geek_outStream.writeDouble(00436754746);         geek_outStream.writeFloat(2.12345f);         geek_outStream.writeInt(3576);         geek_outStream.writeLong(368723776);            geek_outStream.flush();            // Use of readChar()         System.out.println("Use of readChar() : " + Geek_inStream.readChar());            // Use of readByte() :         System.out.println("Use of readByte() : " + Geek_inStream.readByte());            // Use of readDouble() :         System.out.println("Use of readDouble() : " + Geek_inStream.readDouble());            // Use of readFloat() :         System.out.println("Use of readFloat() : " + Geek_inStream.readFloat());            // Use of readInt() :         System.out.println("Use of readInt() : " + Geek_inStream.readInt());            // Use of readLong() :         System.out.println("Use of readLong() : " + Geek_inStream.readLong());     } }

  Output :

  Use of readChar() : G
  Use of readByte() : 71
  Use of readDouble() : 7.5225574E7
  Use of readFloat() : 2.12345
  Use of readInt() : 3576
  Use of readLong() : 368723776

• readUnsignedByte() : java.io.ObjectInputStream.readUnsignedByte() reads an unsigned 8 bit byte.
  Syntax :

  public int readUnsignedByte()
  Parameters : 
  -----------
  Return : 
  reads an unsigned 8 bit byte.
  Exception :
  -> IOException : in case of any IO error occurs.
  -> EOFException : if end of the stream is reached.
  

• readUnsignedShort() : java.io.ObjectInputStream.readUnsignedShort() reads an unsigned 16 bit short.
  Syntax :

  public int readUnsignedShort()
  Parameters : 
  -----------
  Return : 
  reads an unsigned 16 bit short.
  Exception :
  -> IOException : in case of any IO error occurs.
  -> EOFException : if end of the stream is reached.
  

  
  

  
  
  

  // Java program explaining the working of // readUnsignedByte() and readUnsignedShort()    import java.io.*;    public class NewClass {     public static void main(String[] args) throws IOException     {         // create a new file with an ObjectOutputStream and ObjectInputStream         FileOutputStream geek_out = new FileOutputStream("GEEKS.txt");         ObjectOutputStream geek_outStream = new ObjectOutputStream(geek_out);                    // create an ObjectInputStream for the file we created before         ObjectInputStream Geek_inStream                      = new ObjectInputStream(new FileInputStream("GEEKS.txt"));            geek_outStream.writeByte(111);         geek_outStream.writeShort(121212);            geek_outStream.flush();            // Use of readUnsignedByte()         System.out.println("readUnsignedByte() : "                          + Geek_inStream.readUnsignedByte());            // Use of readUnsignedShort() :         System.out.println("readUnsignedShort() : "                          + Geek_inStream.readUnsignedShort());     } }

  Output :

  readUnsignedByte() : 111
  readUnsignedShort() : 55676

• readUTF() : java.io.ObjectInputStream.readUTF()reads String in modified UTF-8 (Unicode Transformation Format) format. UTF -8 means it uses 8-bit blocks to represent a character.
  Syntax :

  public String readUTF()
  Parameters : 
  public final Object readObject()
  Return : 
  reads String in modified UTF-8 (Unicode Transformation Format) format
  Exception :
  -> IOException : in case of any IO error occurs.
  

  
  

  
  
  

  // Java program explaining the working of readUTF()    import java.io.*;    public clas// Java program explaining the working of readUTF()    import java.io.*;    public class NewClass {     public static void main(String[] args) throws IOException, ClassNotFoundException     {         // create a new file with an ObjectOutputStream and ObjectInputStream         FileOutputStream geek_out = new FileOutputStream("GEEKS.txt");         ObjectOutputStream geek_outStream = new ObjectOutputStream(geek_out);            ObjectInputStream Geek_inStream                      = new ObjectInputStream(new FileInputStream("GEEKS.txt"));                       geek_outStream.writeUTF("gEEKSArehERE");         geek_outStream.flush();            // Use of readUTF() method          System.out.println("Use of readUTF() : " + Geek_inStream.readUTF());     } }

  Output :

  Use of readUTF() : gEEKSArehERE

• skipBytes(int maxlen) : java.io.ObjectInputStream.skipBytes(int maxlen)skips ‘maxlen’ no. of bytes while reading.
  Syntax :
  
  
  
  

  public int skipBytes(int maxlen)
  Parameters : 
  maxlen : max. no. of bytes to be skipped
  Return : 
  no. of bytes to be skipped
  Exception :
  -> IOException : in case of any IO error occurs.
  

  
  

  
  
  

  // Java program explaining the working of skipBytes()    import java.io.*;    public class NewClass {     public static void main(String[] args) throws IOException, ClassNotFoundException     {         // create a new file with an ObjectOutputStream and ObjectInputStream         FileOutputStream geek_out = new FileOutputStream("GEEKS.txt");         ObjectOutputStream geek_outStream = new ObjectOutputStream(geek_out);            ObjectInputStream Geek_inStream                      = new ObjectInputStream(new FileInputStream("GEEKS.txt"));                                geek_outStream.writeUTF("gEEKSArehERE");         geek_outStream.flush();            // Use of skipBytes() :          Geek_inStream.skipBytes(7);                    for (int i = 2; i < Geek_inStream.available(); i++)          {             System.out.print((char) Geek_inStream.readByte());         }     } }

  Output :

  Are

• readFully(byte[] destination) : java.io.ObjectInputStream.readFully(byte[] destination)reads all the bytes from source to the destination array.
  Syntax :

  public void readFully(byte[] destination)
  Parameters : 
  destination : the buffer in which the data is to be read
  Return : 
  returns the 32 bit float read
  Exception :
  -> IOException : in case of any IO error occurs.
  -> EOFException : if End of stream is reached
  

  
  

  
  
  

  // Java program explaining the working of readFully()    import java.io.*;    public class NewClass {     public static void main(String[] args) throws IOException, ClassNotFoundException     {         // create a new file with an ObjectOutputStream and ObjectInputStream         FileOutputStream geek_out = new FileOutputStream("GEEKS.txt");         ObjectOutputStream geek_outStream = new ObjectOutputStream(geek_out);            ObjectInputStream Geek_inStream                     = new ObjectInputStream(new FileInputStream("GEEKS.txt"));            geek_outStream.writeUTF("gEEKSArehERE");         geek_outStream.flush();                           byte[] destination = new byte[14];                    // Use of readFully()          Geek_inStream.readFully(destination);                    String str = new String(destination);         System.out.println("Use of readFully(destination, offset, maxlen) : "+str);     } }

  Output :

  Use of readFully(destination, offset, maxlen) : gEEKSArehERE

• readFully(byte[] destination, int offset, int maxlen) : java.io.ObjectInputStream.readFully(byte[] destination, int offset, int maxlen)reads some the bytes (starting from offset to maxlen position) from source to the destination array .
  Syntax :

  public void readFully(byte[] destination, int offset, int maxlen)
  Parameters : 
  destination : the buffer in which the data is to be read
  offset : starting position of the buffer
  maxlen : max no. of bytes to be read
  Return : 
  void
  Exception :
  -> IOException : in case of any IO error occurs.
  -> EOFException : if End of stream is reached
  

  
  

  
  
  

  // Java program explaining the working of  // readFully(byte[] destination, int offset, int maxlen)    import java.io.*;    public class NewClass {     public static void main(String[] args) throws IOException, ClassNotFoundException     {         // create a new file with an ObjectOutputStream and ObjectInputStream         FileOutputStream geek_out = new FileOutputStream("GEEKS.txt");         ObjectOutputStream geek_outStream = new ObjectOutputStream(geek_out);            ObjectInputStream Geek_inStream                      = new ObjectInputStream(new FileInputStream("GEEKS.txt"));            geek_outStream.writeUTF("gEEKSArehERE");         geek_outStream.flush();                   byte[] destination = new byte[14];                    // Use of readFully(byte[] destination, int offset, int maxlen)          Geek_inStream.readFully(destination, 3, 7);                    String str = new String(destination);         System.out.println("Use of readFully(destination, offset, maxlen) : "+ str);     } }

  Output :

  Use of readFully(destination, offset, maxlen) : geeks

This article is contributed by Mohit Gupta 🙂. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.