Een ObjectOutputStream schrijft primitieve gegevenstypen en grafieken van Java-objecten naar een OutputStream. De objecten kunnen worden gelezen (opnieuw samengesteld) met behulp van een ObjectInputStream. Permanente opslag van objecten kan worden bereikt door een bestand voor de stream te gebruiken. 

• Alleen objecten die de java.io.Serializable-interface ondersteunen, kunnen naar streams worden geschreven. De klasse van elk serialiseerbaar object is gecodeerd, inclusief de klassenaam en handtekening van de klasse, de waarden van de velden en arrays van het object en de sluiting van alle andere objecten waarnaar wordt verwezen vanuit de initiële objecten.
• De Java ObjectOutputStream wordt vaak gebruikt in combinatie met een Java ObjectInputStream. De ObjectOutputStream wordt gebruikt om de Java-objecten te schrijven en de ObjectInputStream wordt gebruikt om de objecten opnieuw te lezen. 

Constructeurs:   

beschermd ObjectOutputStream() :Bied een manier aan voor subklassen die ObjectOutputStream volledig opnieuw implementeren, zodat ze geen privégegevens hoeven toe te wijzen die zojuist door deze implementatie van ObjectOutputStream worden gebruikt.ObjectOutputStream(OutputStream uit) :Creëert een ObjectOutputStream die naar de opgegeven OutputStream schrijft. 

Methoden:   

beschermde leegte annotateClass(Klasse cl):Subklassen kunnen deze methode implementeren om het mogelijk te maken dat klassegegevens in de stroom worden opgeslagen. Standaard doet deze methode niets. De overeenkomstige methode in ObjectInputStream is solveClass. Deze methode wordt precies één keer aangeroepen voor elke unieke klasse in de stream. De klassenaam en handtekening zijn al naar de stream geschreven. Deze methode kan gratis gebruik maken van ObjectOutputStream om elke representatie van de klasse op te slaan die zij geschikt acht (bijvoorbeeld de bytes van het klassenbestand). De methode solveClass in de corresponderende subklasse van ObjectInputStream moet alle gegevens of objecten lezen en gebruiken die door annotateClass zijn geschreven. 

  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();  } } 

Uitgang:  

A

beschermde leegte annotateProxyClass(Klasse cl) :Subklassen kunnen deze methode implementeren om aangepaste gegevens in de stroom op te slaan, samen met descriptors voor dynamische proxyklassen. Deze methode wordt precies één keer aangeroepen voor elke unieke proxyklassedescriptor in de stroom. De standaardimplementatie van deze methode in ObjectOutputStream doet niets.
De overeenkomstige methode in ObjectInputStream is solveProxyClass. Voor een bepaalde subklasse van ObjectOutputStream die deze methode overschrijft, moet de methode solveProxyClass in de corresponderende subklasse van ObjectInputStream alle gegevens of objecten lezen die zijn geschreven door 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();  } } 

Uitgang:  

A

leegte close() :Sluit de stream. Deze methode moet worden aangeroepen om alle bronnen die aan de stream zijn gekoppeld, vrij te geven. 

  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();  } } 

Uitgang: 

3

void defaultWriteObject() :Schrijf de niet-statische en niet-tijdelijke velden van de huidige klasse naar deze stream. Dit kan alleen worden aangeroepen vanuit de writeObject-methode van de klasse die wordt geserialiseerd. Het zal de NotActiveException genereren als het anders wordt aangeroepen. 

  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();  }  }  } 

Uitgang:  

A

beschermde leegteafvoer() :Voer alle gebufferde gegevens af in ObjectOutputStream. Vergelijkbaar met flush, maar verspreidt de flush niet naar de onderliggende stroom. 

  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();  } } 

beschermde booleaanse enableReplaceObject (booleaanse enable):Schakel de stream in om objecten in de stream te vervangen. Indien ingeschakeld, wordt de methode ReplaceObject aangeroepen voor elk object dat wordt geserialiseerd. 
Als enable waar is en er een beveiligingsmanager is geïnstalleerd, roept deze methode eerst de checkPermission-methode van de beveiligingsmanager aan met de machtiging SerializablePermission('enableSubstitution') om er zeker van te zijn dat de stream toestemming heeft om objecten in de stream te vervangen. 

  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();  } } 

Uitgang:  

false A

ObjectOutputStream.PutField putFields():Haal het object op dat wordt gebruikt om persistente velden te bufferen die naar de stream moeten worden geschreven. De velden worden naar de stream geschreven wanneer de writeFields-methode wordt aangeroepen. 

  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();  } } 

Uitgang:  

A

beschermd object ReplaceObject(Object obj):Met deze methode kunnen vertrouwde subklassen van ObjectOutputStream tijdens de serialisatie het ene object door het andere vervangen. Het vervangen van objecten is uitgeschakeld totdat enableReplaceObject wordt aangeroepen. De methode enableReplaceObject controleert of de stream die om vervanging vraagt, kan worden vertrouwd. Het eerste exemplaar van elk object dat in de serialisatiestroom wordt geschreven, wordt doorgegeven aan ReplaceObject. Daaropvolgende verwijzingen naar het object worden vervangen door het object dat wordt geretourneerd door de oorspronkelijke aanroep van ReplaceObject. Om ervoor te zorgen dat de privéstatus van objecten niet onbedoeld wordt blootgesteld, mogen alleen vertrouwde streams ReplaceObject gebruiken. 
Deze methode wordt slechts één keer aangeroepen wanneer elk object voor het eerst wordt aangetroffen. Alle volgende verwijzingen naar het object worden doorgestuurd naar het nieuwe object. Deze methode moet het te vervangen object of het originele object retourneren.
Null kan worden geretourneerd als het object dat moet worden vervangen, maar kan NullReferenceException veroorzaken in klassen die verwijzingen naar het oorspronkelijke object bevatten, omdat deze mogelijk een object verwachten in plaats van null. 

  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();  } } 

Uitgang:  

GeeksforGeeks

void useProtocolVersion(int-versie):Geef de streamprotocolversie op die moet worden gebruikt bij het schrijven van de stream. Deze routine biedt een hook waarmee de huidige versie van Serialisatie kan schrijven in een indeling die achterwaarts compatibel is met een eerdere versie van de streamindeling.
Er zal alles aan worden gedaan om te voorkomen dat er nog meer achterwaartse onverenigbaarheden worden geïntroduceerd; soms is er echter geen ander alternatief. 

  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();  } } 

Uitgang:  

GeeksforGeeks

Volgend artikel: Java.io.ObjectOutputStream-klasse in Java | Stel 2 in