logo

TechCodeview

Classe Java.io.ObjectOutputStream en Java | Set 1

Un ObjectOutputStream escriu tipus de dades primitius i gràfics d'objectes Java a un OutputStream. Els objectes es poden llegir (reconstituir) mitjançant un ObjectInputStream. L'emmagatzematge persistent d'objectes es pot aconseguir utilitzant un fitxer per al flux. 

  • Només els objectes que admeten la interfície java.io.Serializable es poden escriure als fluxos. La classe de cada objecte serialitzable està codificada incloent el nom de classe i la signatura de la classe, els valors dels camps i matrius de l'objecte i el tancament de qualsevol altre objecte referenciat des dels objectes inicials.
  • El Java ObjectOutputStream s'utilitza sovint juntament amb un Java ObjectInputStream. ObjectOutputStream s'utilitza per escriure els objectes Java i ObjectInputStream s'utilitza per tornar a llegir els objectes. 

Constructors:   

    ObjectOutputStream() protegit:Proporcioneu una manera perquè les subclasses que estan reimplementant completament ObjectOutputStream no hagin d'assignar dades privades que acaba d'utilitzar aquesta implementació d'ObjectOutputStream.ObjectOutputStream (sortida de sortida):Crea un ObjectOutputStream que escriu al OutputStream especificat. 

Mètodes:   



arp - una ordre
    protegit void annotateClass(Classe cl):Les subclasses poden implementar aquest mètode per permetre que les dades de classe s'emmagatzemin al flux. Per defecte, aquest mètode no fa res. El mètode corresponent a ObjectInputStream és resolveClass. Aquest mètode s'anomena exactament una vegada per a cada classe única del flux. El nom i la signatura de la classe ja s'hauran escrit al tauler d'activitat. Aquest mètode pot fer ús lliure de l'ObjectOutputStream per desar qualsevol representació de la classe que consideri adequada (per exemple, els bytes del fitxer de classe). El mètode resolveClass de la subclasse corresponent d'ObjectInputStream ha de llegir i utilitzar qualsevol dada o objecte escrit per annotateClass. 
  Syntax :  protected void annotateClass(Class cl) throws IOException   Parameters:   cl - the class to annotate custom data for   Throws:   IOException
Java 
//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();  } }

Sortida:  

A
    protegit void annotateProxyClass(Class cl):Les subclasses poden implementar aquest mètode per emmagatzemar dades personalitzades al flux juntament amb descriptors per a classes proxy dinàmiques. Aquest mètode s'anomena exactament una vegada per a cada descriptor de classe de proxy únic del flux. La implementació per defecte d'aquest mètode a ObjectOutputStream no fa res.
    El mètode corresponent a ObjectInputStream és resolveProxyClass. Per a una subclasse determinada d'ObjectOutputStream que anul·la aquest mètode, el mètode resolveProxyClass de la subclasse corresponent d'ObjectInputStream ha de llegir qualsevol dada o objecte escrit per annotateProxyClass. 
  Syntax :  protected void annotateProxyClass(Class cl) throws IOException   Parameters:   cl - the proxy class to annotate custom data for   Throws:   IOException
Java 
//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();  } }

Sortida:  

A
    void close():Tanca el flux. Cal cridar aquest mètode per alliberar qualsevol recurs associat al flux. 
  Syntax :  public void close() throws IOException   Throws:   IOException
Java 
//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();  } }
    Sortida: 
3
    void defaultWriteObject():Escriu els camps no estàtics i no transitoris de la classe actual en aquest flux. Això només es pot cridar des del mètode writeObject de la classe que s'està serialitzant. Llançarà la NotActiveException si es crida d'una altra manera. 
  Syntax :  public void defaultWriteObject() throws IOException   Throws:   IOException
Java 
//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();  }  }  }

Sortida:  

A
    drenatge buit protegit():Escorreu les dades emmagatzemades a ObjectOutputStream. Semblant al flush, però no propaga el flush al flux subjacent. 
  Syntax :  protected void drain() throws IOException   Throws:   IOException
Java 
//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();  } }
    protegit booleà enableReplaceObject (habilitat booleà):Habiliteu el flux per substituir els objectes del flux. Quan està habilitat, es crida el mètode replaceObject per a cada objecte que es serialitza. 
    Si enable és cert i hi ha un gestor de seguretat instal·lat, aquest mètode crida primer al mètode checkPermission del gestor de seguretat amb un permís SerializablePermission('enableSubstitution') per assegurar-se que està bé habilitar el flux per substituir els objectes del flux. 
  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 
//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();  } }

Sortida:  

false A
    ObjectOutputStream.PutField putFields():Recupereu l'objecte utilitzat per a la memòria intermèdia dels camps persistents per escriure'ls al flux. Els camps s'escriuran al flux quan es cridi al mètode writeFields. 
  Syntax :  public ObjectOutputStream.PutField putFields() throws IOException   Returns:   an instance of the class Putfield that holds the serializable fields   Throws:   IOException
Java 
//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();  } }

Sortida:  

A
    Objecte protegit substituirObject(Objecte objecte):Aquest mètode permetrà que les subclasses de confiança d'ObjectOutputStream substitueixin un objecte per un altre durant la serialització. La substitució d'objectes està desactivada fins que es crida enableReplaceObject. El mètode enableReplaceObject comprova que es pot confiar en el flux que sol·licita la substitució. La primera ocurrència de cada objecte escrit al flux de serialització es passa a replaceObject. Les referències posteriors a l'objecte se substitueixen per l'objecte retornat per la crida original a substituirObject. Per garantir que l'estat privat dels objectes no s'exposa involuntàriament, només els fluxos de confiança poden utilitzar replaceObject. 
    Aquest mètode només es crida una vegada quan es troba per primera vegada cada objecte. Totes les referències posteriors a l'objecte es redirigiran al nou objecte. Aquest mètode hauria de retornar l'objecte a substituir o l'objecte original.
    Es pot retornar Null com a objecte a substituir, però pot provocar una NullReferenceException en classes que contenen referències a l'objecte original, ja que poden estar esperant un objecte en lloc de nul. 
  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 
//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();  } }

Sortida:  

GeeksforGeeks
    void useProtocolVersion (versió int):Especifiqueu la versió del protocol de flux que s'ha d'utilitzar quan escriu el flux. Aquesta rutina proporciona un ganxo per permetre que la versió actual de la serialització escrigui en un format compatible amb una versió anterior del format del flux.
    Es farà tot el possible per evitar la introducció d'incompatibilitats cap enrere addicionals; però de vegades no hi ha cap altra alternativa. 
  Syntax :  public void useProtocolVersion(int version) throws IOException   Parameters:   version - use ProtocolVersion from java.io.ObjectStreamConstants.   Throws:   IllegalStateException IllegalArgumentException IOException
Java 
 //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();  } }

Sortida:  

GeeksforGeeks

Article següent: Classe Java.io.ObjectOutputStream en Java | Set 2


 

Crea un qüestionari