Clase Java.io.ObjectOutputStream en Java | Serie 1

Un ObjectOutputStream escribe tipos de datos primitivos y gráficos de objetos Java en un OutputStream. Los objetos se pueden leer (reconstituir) usando un ObjectInputStream. El almacenamiento persistente de objetos se puede lograr mediante el uso de un archivo para la secuencia. 

• Solo los objetos que admiten la interfaz java.io.Serializable se pueden escribir en flujos. La clase de cada objeto serializable se codifica, incluido el nombre de clase y la firma de la clase, los valores de los campos y arrays del objeto y el cierre de cualquier otro objeto al que se hace referencia desde los objetos iniciales.
• Java ObjectOutputStream se usa a menudo junto con Java ObjectInputStream. ObjectOutputStream se usa para escribir los objetos Java, y ObjectInputStream se usa para leer los objetos nuevamente. 

Constructores :  

• Protected ObjectOutputStream() : Proporcione una forma para que las subclases que están reimplementando completamente ObjectOutputStream no tengan que asignar datos privados que acaba de usar esta implementación de ObjectOutputStream.
• ObjectOutputStream(OutputStream out): crea un ObjectOutputStream que escribe en el OutputStream especificado. 

Métodos:  

• protected void annotateClass(Class cl) : las subclases pueden implementar este método para permitir que los datos de la clase se almacenen en la secuencia. Por defecto, este método no hace nada. El método correspondiente en ObjectInputStream es resolveClass. Este método se llama exactamente una vez para cada clase única en la secuencia. El nombre de la clase y la firma ya se habrán escrito en la transmisión. Este método puede hacer uso gratuito de ObjectOutputStream para guardar cualquier representación de la clase que considere adecuada (por ejemplo, los bytes del archivo de clase). El método resolveClass en la subclase correspondiente de ObjectInputStream debe leer y usar cualquier dato u objeto escrito por annotateClass. 

Syntax :protected void annotateClass(Class cl)
                      throws IOException
Parameters:
cl - the class to annotate custom data for
Throws:
IOException 

//Java program demonstrating ObjectOutputStream methods
//illustrating annotateClass(Class<?> cl) method
 
import java.io.*;
class ObjectOutputStreamDemo extends ObjectOutputStream
{
    public ObjectOutputStreamDemo(OutputStream out) throws IOException
    {
        super(out);
    }
     
    public static void main(String[] args) throws IOException,
    ClassNotFoundException
    {
        FileOutputStream fout = new FileOutputStream("file.txt");
        ObjectOutputStreamDemo oot = new ObjectOutputStreamDemo(fout);
        Character c = 'A';
         
        //illustrating annotateClass(Class<?> cl) method
        oot.annotateClass(Character.class);
         
        //Write the specified object to the ObjectOutputStream
        oot.writeObject(c);
         
        //flushing the stream
        oot.flush();
         
        //closing the stream
        oot.close();
         
        FileInputStream fin = new FileInputStream("file.txt");
        ObjectInputStream oit = new ObjectInputStream(fin);
        System.out.print(oit.readObject());
        oit.close();
    }
}

Producción : 

A

• protected void annotateProxyClass(Class cl) : las subclases pueden implementar este método para almacenar datos personalizados en la transmisión junto con descriptores para clases de proxy dinámico. Este método se llama exactamente una vez para cada descriptor de clase de proxy único en la secuencia. La implementación predeterminada de este método en ObjectOutputStream no hace nada.
  El método correspondiente en ObjectInputStream es resolveProxyClass. Para una subclase dada de ObjectOutputStream que reemplaza este método, el método resolveProxyClass en la subclase correspondiente de ObjectInputStream debe leer cualquier dato u objeto escrito por annotateProxyClass. 

Syntax :protected void annotateProxyClass(Class cl)
                           throws IOException
Parameters:
cl - the proxy class to annotate custom data for
Throws:
IOException

//Java program demonstrating ObjectOutputStream
//illustrating annotateProxyClass(Class<?> cl) method
import java.io.*;
 
class ObjectOutputStreamDemo extends ObjectOutputStream
{
    public ObjectOutputStreamDemo(OutputStream out) throws IOException
    {
        super(out);
    }
     
    public static void main(String[] args) throws IOException,
    ClassNotFoundException
    {
        FileOutputStream fout = new FileOutputStream("file.txt");
        ObjectOutputStreamDemo oot = new ObjectOutputStreamDemo(fout);
         
        Character c = 'A';
         
        //illustrating annotateProxyClass(Class<?> cl) method
        oot.annotateProxyClass(Character.class);
         
        //Write the specified object to the ObjectOutputStream
        oot.writeObject(c);
         
        //flushing
        oot.flush();
         
        //closing the stream
        oot.close();
         
        FileInputStream fin = new FileInputStream("file.txt");
        ObjectInputStream oit = new ObjectInputStream(fin);
        System.out.print(oit.readObject());
        oit.close();
    }
}

Producción : 

A

• void close() : Cierra la secuencia. Este método debe llamarse para liberar cualquier recurso asociado con la secuencia. 

Syntax :public void close()
           throws IOException
Throws:
IOException

//Java program demonstrating ObjectOutputStream
//illustrating close() method
 
import java.io.*;
class ObjectOutputStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        FileOutputStream fout = new FileOutputStream("file.txt");
        ObjectOutputStream oot = new ObjectOutputStream(fout);
        oot.write(3);
         
        //illustrating close()
        oot.close();
         
        FileInputStream fin = new FileInputStream("file.txt");
        ObjectInputStream oit = new ObjectInputStream(fin);
        System.out.println(oit.read());
        oit.close();
    }
}

• Producción : 

3

• void defaultWriteObject() : escribe los campos no estáticos y no transitorios de la clase actual en esta secuencia. Esto solo se puede llamar desde el método writeObject de la clase que se serializa. Lanzará la NotActiveException si se llama de otra manera. 

Syntax :public void defaultWriteObject()
                        throws IOException
Throws:
IOException 

//Java program demonstrating ObjectOutputStream
//illustrating defaultWriteObject() method
 
import java.io.*;
class ObjectOutputStreamDemo
{
    public static void main(String[] arg) throws IOException,
            ClassNotFoundException
    {
            Character a = 'A';
            FileOutputStream fout = new FileOutputStream("file.txt");
            ObjectOutputStream oot = new ObjectOutputStream(fout);
            oot.writeChar(a);
            oot.flush();
             
            // close the stream
            oot.close();
             
            FileInputStream fin = new FileInputStream("file.txt");
            ObjectInputStream oit = new ObjectInputStream(fin);
             
            // reading the character
            System.out.println(oit.readChar());
    }
}
    class demo implements Serializable
    {
        String s = "GeeksfoGeeks";
        private void writeObject(ObjectOutputStream out)
                throws IOException, ClassNotFoundException
        {
            //demonstrating defaultWriteObject()
            out.defaultWriteObject();
 
        }
    }
 
     }

Producción : 

A

• Vacío vacío protegido() : Drenar cualquier dato almacenado en búfer en ObjectOutputStream. Similar a flush pero no propaga el flush a la corriente subyacente. 

Syntax :protected void drain()
              throws IOException
Throws:
IOException

//Java program demonstrating ObjectOutputStream methods
//illustrating drain() method
import java.io.*;
class ObjectOutputStreamDemo extends ObjectOutputStream
{
    public ObjectOutputStreamDemo(OutputStream out) throws IOException
    {
        super(out);
    }
    public static void main(String[] arg) throws IOException,
            ClassNotFoundException
    {
            FileOutputStream fout = new FileOutputStream("file.txt");
            ObjectOutputStream oot = new ObjectOutputStream(fout);
            ObjectOutputStreamDemo obj = new ObjectOutputStreamDemo(oot);
             
            //illustrating drain()
            obj.drain();
             
            //closing the underlying stream
            oot.close();
            fout.close();
    }
}

• booleano protegido enableReplaceObject (habilitación booleana): habilite la secuencia para que reemplace los objetos en la secuencia. Cuando está habilitado, se llama al método replaceObject para cada objeto que se serializa. 
  Si enable es verdadero y hay un administrador de seguridad instalado, este método primero llama al método checkPermission del administrador de seguridad con un permiso SerializablePermission («enableSubstitution») para asegurarse de que está bien habilitar la transmisión para reemplazar objetos en la transmisión. 

Syntax :protected boolean enableReplaceObject(boolean enable)
                               throws SecurityException
Parameters:
enable - boolean parameter to enable replacement of objects
Returns:
the previous setting before this method was invoked
Throws:
SecurityException

//Java program demonstrating ObjectOutputStream
//illustrating enableReplaceObject method
import java.io.*;
class ObjectOutputStreamDemo extends ObjectOutputStream
{
    public ObjectOutputStreamDemo(OutputStream out) throws IOException
    {
        super(out);
    }
 
    public static void main(String[] args) throws IOException,
        ClassNotFoundException
        {
            FileOutputStream fout = new FileOutputStream("file.txt");
            ObjectOutputStreamDemo oot = new ObjectOutputStreamDemo(fout);
            Character c = 'A';
             
            //illustrating enableReplaceObject method
            System.out.println(oot.enableReplaceObject(true));
             
            //Write the specified object to the ObjectOutputStream
            oot.writeObject(c);
             
            //flushing
            oot.flush();
             
            //closing the stream
            oot.close();
             
            FileInputStream fin = new FileInputStream("file.txt");
            ObjectInputStream oit = new ObjectInputStream(fin);
            System.out.print(oit.readObject());
            oit.close();
    }
}

Producción : 

false
A

• ObjectOutputStream.PutField putFields(): recupera el objeto utilizado para almacenar en búfer los campos persistentes que se escribirán en la secuencia. Los campos se escribirán en la secuencia cuando se llame al método writeFields. 

Syntax :public ObjectOutputStream.PutField putFields()
                                      throws IOException
Returns:
an instance of the class Putfield that holds the serializable fields
Throws:
IOException

//Java program demonstrating ObjectOutputStream
//illustrating PutField method
import java.io.*;
class ObjectOutputStreamDemo
{
    public static void main(String[] arg) throws IOException,
            ClassNotFoundException
    {
        Character a ='A';
        FileOutputStream fout = new FileOutputStream("file.txt");
        ObjectOutputStream oot = new ObjectOutputStream(fout);
        oot.writeChar(a);
        oot.flush();
         
        // close the stream
        oot.close();
         
        FileInputStream fin = new FileInputStream("file.txt");
        ObjectInputStream oit = new ObjectInputStream(fin);
         
        // reading the character
        System.out.println(oit.readChar());
    }
}
class demo implements Serializable
{
    private void writeObject(ObjectOutputStream out)
            throws IOException, ClassNotFoundException
    {
        // Retrieve the object used to buffer
        // persistent fields to be written to the stream
        ObjectOutputStream.PutField fields = out.putFields();
 
    }
}

Producción : 

A

• Objeto protegido replaceObject(Object obj): este método permitirá que las subclases confiables de ObjectOutputStream sustituyan un objeto por otro durante la serialización. La sustitución de objetos está deshabilitada hasta que se llama a enableReplaceObject. El método enableReplaceObject comprueba que se puede confiar en la secuencia que solicita el reemplazo. La primera aparición de cada objeto escrito en el flujo de serialización se pasa a replaceObject. Las referencias posteriores al objeto se reemplazan por el objeto devuelto por la llamada original a replaceObject. Para asegurarse de que el estado privado de los objetos no se exponga involuntariamente, solo las transmisiones confiables pueden usar replaceObject. 
  Este método se llama solo una vez cuando se encuentra cada objeto por primera vez. Todas las referencias posteriores al objeto se redirigirán al nuevo objeto. Este método debe devolver el objeto a sustituir o el objeto original.
  Null se puede devolver como el objeto que se va a sustituir, pero puede causar NullReferenceException en las clases que contienen referencias al objeto original, ya que pueden estar esperando un objeto en lugar de nulo. 

Syntax :protected Object replaceObject(Object obj)
                        throws IOException
Parameters:
obj - the object to be replaced
Returns:
the alternate object that replaced the specified one
Throws:
IOException

//Java program demonstrating ObjectOutputStream
//illustrating replaceObject method
import java.io.*;
class ObjectOutputStreamDemo extends ObjectOutputStream
{
    public ObjectOutputStreamDemo(OutputStream out) throws IOException
    {
        super(out);
    }
 
    public static void main(String[] args) throws IOException,
    ClassNotFoundException
    {
        FileOutputStream fout = new FileOutputStream("file.txt");
        ObjectOutputStreamDemo oot = new ObjectOutputStreamDemo(fout);
        String a = "forGeeks";
        String b = "Geeks";
 
        //Write the specified object to the ObjectOutputStream
        oot.writeObject(a);
         
        //flushing the stream
        oot.flush();
 
        oot.enableReplaceObject(true);
         
        //illustrating replaceObject
        System.out.print(oot.replaceObject(b));
         
        //closing the stream
        oot.close();
         
        FileInputStream fin = new FileInputStream("file.txt");
        ObjectInputStream oit = new ObjectInputStream(fin);
        System.out.print(oit.readObject());
        oit.close();
    }
}

Producción : 

GeeksforGeeks

• void useProtocolVersion(int version) : especifique la versión del protocolo de flujo que se usará al escribir el flujo. Esta rutina proporciona un gancho para habilitar la versión actual de Serialización para escribir en un formato que sea compatible con una versión anterior del formato de flujo.
  Se hará todo lo posible para evitar la introducción de incompatibilidades anteriores adicionales; sin embargo, a veces no hay otra alternativa. 

Syntax :public void useProtocolVersion(int version)
                        throws IOException
Parameters:
version - use ProtocolVersion from java.io.ObjectStreamConstants.
Throws:
IllegalStateException 
IllegalArgumentException
IOException 

//Java program demonstrating ObjectOutputStream
 //illustrating useProtocolVersion() method
import java.io.*;
class ObjectOutputStreamDemo extends ObjectOutputStream
{
    public ObjectOutputStreamDemo(OutputStream out) throws IOException
    {
        super(out);
    }
 
    public static void main(String[] args) throws IOException,
        ClassNotFoundException
    {
        FileOutputStream fout = new FileOutputStream("file.txt");
        ObjectOutputStreamDemo oot = new ObjectOutputStreamDemo(fout);
        String a = "forGeeks";
        String b = "Geeks";
 
        //illustrating useProtocolVersion()
        oot.useProtocolVersion(ObjectStreamConstants.PROTOCOL_VERSION_2);
 
        //Write the specified object to the ObjectOutputStream
        oot.writeObject(b);
        oot.writeObject(a);
 
        //flushing the stream
        oot.flush();
 
        oot.close();
        FileInputStream fin = new FileInputStream("file.txt");
        ObjectInputStream oit = new ObjectInputStream(fin);
        System.out.print(oit.readObject());
        System.out.print(oit.readObject());
        oit.close();
    }
}

Producción : 

GeeksforGeeks

Artículo siguiente: Clase Java.io.ObjectOutputStream en Java | conjunto 2

Este artículo es una contribución de Nishant Sharma . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@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.