Clase Java.io.ObjectInputStream en Java | Serie 1

Posted on by Rudeus Greyrat

La clase ObjectInputStream deserializa los datos primitivos y los objetos escritos previamente por ObjectOutputStream .

  • Tanto ObjectOutputStream como ObjectInputStream se utilizan, ya que proporciona almacenamiento para gráficos de objetos.
  • Asegura que el objeto para el que está trabajando coincida con las clases de JVM, es decir, Java Virtual Machine. Solo se pueden leer los Objetos de las secuencias que admiten Serializable o Externalizable : clases de E/S, de lo contrario, error.
    Serializable es básicamente un tipo de marcador para JVM (Java Virtual Machine) que lo dirige a escribir el estado del Objeto presente en Stream

Declaración :

public class ObjectInputStream
  extends InputStream
    implements ObjectInput, ObjectStreamConstants

Constructores :

  • Protected ObjectInputStream() : ayude a las subclases a no asignar datos privados utilizados por ObjectInputStream, si están reimplementando ObjectInputStream.
  • ObjectInputStream (InputStream source_input): crea ObjectInputStream que lee datos del flujo de entrada ‘source_input’.

Métodos:

  • read() : java.io.ObjectInputStream.read() lee el byte de datos y los bloquea en caso de que no haya datos para leer.
    Sintaxis: 
    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() lee en un booleano.
    Sintaxis: 
    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());
            }
      
        }
    }

    Producción :

    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) lee parte de los datos del ‘búfer’ comenzando desde la posición de compensación hasta la posición maxlen de el búfer
    Sintaxis: 
    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]);
            }
        }
    }

    Producción :

    GeeksForGeeks
  • readByte() : java.io.ObjectInputStream.readByte() lee bytes de 8 bits.
    Sintaxis: 
    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() lee 16 bits de caracteres.
    Sintaxis: 
    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() lee el doble de 64 bits.
    Sintaxis: 
    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() lee un flotante de 32 bits.
    Sintaxis: 
    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() lee un int de 32 bits.
    Sintaxis: 
    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() lee una longitud de 64 bits.
    Sintaxis: 
    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());
        }
    }

    Producción :

    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() lee un byte de 8 bits sin firmar.
    Sintaxis: 
    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() lee un corto de 16 bits sin firmar.
    Sintaxis: 
    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());
        }
    }

    Producción :

    readUnsignedByte() : 111
readUnsignedShort() : 55676
  • readUTF() : java.io.ObjectInputStream.readUTF() lee String en formato UTF-8 (Unicode Transformation Format) modificado. UTF -8 significa que utiliza bloques de 8 bits para representar un carácter.
    Sintaxis: 
    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());
        }
    }

    Producción :

    Use of readUTF() : gEEKSArehERE
  • skipBytes(int maxlen) : java.io.ObjectInputStream.skipBytes(int maxlen) salta ‘maxlen’ no. de bytes durante la lectura.
    Sintaxis: 
    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());
            }
        }
    }

    Producción :

    Are
  • readFully(byte[] destino) : java.io.ObjectInputStream.readFully(byte[] destino) lee todos los bytes desde el origen hasta la array de destino.
    Sintaxis: 
    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);
        }
    }

    Producción :

    Use of readFully(destination, offset, maxlen) : gEEKSArehERE
  • readFully(byte[] destino, int offset, int maxlen) : java.io.ObjectInputStream.readFully(byte[] destino, int offset, int maxlen) lee algunos bytes (desde el desplazamiento hasta la posición maxlen) desde el origen hasta el destino array
    Sintaxis: 
    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);
        }
    }

    Producción :

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

Este artículo es aportado por Mohit Gupta 🙂 . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *