logo

TechCodeview

Třída Java.io.ObjectOutputStream v Javě | Sada 1

ObjectOutputStream zapisuje primitivní datové typy a grafy objektů Java do OutputStream. Objekty lze číst (rekonstituovat) pomocí ObjectInputStream. Trvalé ukládání objektů lze dosáhnout pomocí souboru pro datový proud. 

  • Do streamů lze zapisovat pouze objekty, které podporují rozhraní java.io.Serializable. Třída každého serializovatelného objektu je zakódována včetně názvu třídy a podpisu třídy, hodnot polí a polí objektu a uzavření jakýchkoli dalších objektů, na které se odkazuje z počátečních objektů.
  • Java ObjectOutputStream se často používá společně s Java ObjectInputStream. ObjectOutputStream se používá k zápisu objektů Java a ObjectInputStream se používá k opětovnému čtení objektů. 

Konstruktéři:   

    chráněný ObjectOutputStream() :Poskytněte podtřídám, které zcela reimplementují ObjectOutputStream, způsob, aby nemusely alokovat soukromá data právě používaná touto implementací ObjectOutputStream.ObjectOutputStream(OutputStream out) :Vytvoří ObjectOutputStream, který zapisuje do zadaného OutputStream. 

Metody:   



    chráněná void anotovatClass(Class cl):Podtřídy mohou implementovat tuto metodu, aby umožnily ukládání dat třídy do proudu. Ve výchozím nastavení tato metoda nedělá nic. Odpovídající metodou v ObjectInputStream je resolveClass. Tato metoda se volá přesně jednou pro každou jedinečnou třídu v proudu. Název třídy a podpis již byly zapsány do streamu. Tato metoda může volně používat ObjectOutputStream k uložení jakékoli reprezentace třídy, kterou považuje za vhodnou (například bajtů souboru třídy). Metoda resolveClass v odpovídající podtřídě ObjectInputStream musí číst a používat všechna data nebo objekty zapsané pomocí 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();  } }

výstup:  

A
    chráněná void anotovatProxyClass(Class cl):Podtřídy mohou implementovat tuto metodu k ukládání vlastních dat v proudu spolu s deskriptory pro dynamické třídy proxy. Tato metoda je volána přesně jednou pro každý jedinečný deskriptor třídy proxy v proudu. Výchozí implementace této metody v ObjectOutputStream nedělá nic.
    Odpovídající metodou v ObjectInputStream je resolveProxyClass. Pro danou podtřídu ObjectOutputStream, která přepíše tuto metodu, musí metoda resolveProxyClass v odpovídající podtřídě ObjectInputStream číst všechna data nebo objekty zapsané pomocí 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();  } }

výstup:  

A
    void close() :Zavře proud. Tuto metodu je třeba zavolat, aby se uvolnily všechny prostředky spojené s proudem. 
  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();  } }
    výstup: 
3
    void defaultWriteObject() :Do tohoto proudu zapište nestatická a nepřechodná pole aktuální třídy. To lze volat pouze z metody writeObject serializované třídy. Pokud je volána jinak, vyvolá výjimku NotActiveException. 
  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();  }  }  }

výstup:  

A
    chráněný void drain() :Vypusťte všechna data ve vyrovnávací paměti v ObjectOutputStream. Podobné jako flush, ale nešíří flush do spodního proudu. 
  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();  } }
    chráněná logická hodnota enableReplaceObject(boolean enable):Povolte streamu provádět výměnu objektů ve streamu. Je-li povoleno, je pro každý serializovaný objekt volána metoda replaceObject. 
    Pokud je povoleno nastaveno na hodnotu true a je nainstalován správce zabezpečení, tato metoda nejprve zavolá metodu checkPermission správce zabezpečení s oprávněním SerializablePermission('enableSubstitution'), aby bylo zajištěno, že je v pořádku umožnit streamu nahrazování objektů v proudu. 
  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();  } }

výstup:  

false A
    ObjectOutputStream.PutField putFields():Načtěte objekt používaný k ukládání trvalých polí do vyrovnávací paměti, která mají být zapsána do proudu. Pole budou zapsána do streamu při volání metody 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();  } }

výstup:  

A
    chráněný objekt nahraditObjekt(Object obj):Tato metoda umožní důvěryhodným podtřídám ObjectOutputStream nahradit jeden objekt jiným během serializace. Nahrazování objektů je zakázáno, dokud není zavoláno enableReplaceObject. Metoda enableReplaceObject zkontroluje, zda lze důvěryhodnému datovému proudu požadujícímu provedení náhrady. První výskyt každého objektu zapsaného do serializačního streamu je předán do replaceObject. Následné odkazy na objekt jsou nahrazeny objektem vráceným původním voláním replaceObject. Aby bylo zajištěno, že soukromý stav objektů nebude neúmyslně odhalen, mohou nahradit objekt nahradit pouze důvěryhodné proudy. 
    Tato metoda je volána pouze jednou při prvním setkání s každým objektem. Všechny následné odkazy na objekt budou přesměrovány na nový objekt. Tato metoda by měla vrátit objekt, který má být nahrazen, nebo původní objekt.
    Null lze vrátit jako objekt, který má být nahrazen, ale může způsobit výjimku NullReferenceException ve třídách, které obsahují odkazy na původní objekt, protože mohou očekávat objekt namísto hodnoty 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 
//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();  } }

výstup:  

GeeksforGeeks
    void useProtocolVersion(int verze) :Zadejte verzi protokolu proudu, která se má použít při zápisu datového proudu. Tato rutina poskytuje háček, který umožňuje aktuální verzi serializace zapisovat ve formátu, který je zpětně kompatibilní s předchozí verzí formátu datového proudu.
    Vynaložíme veškeré úsilí, aby nedošlo k zavedení dalších zpětných nekompatibilit; někdy však není jiná 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();  } }

výstup:  

GeeksforGeeks

Další článek: Třída Java.io.ObjectOutputStream v Javě | Sada 2


 

Vytvořit kvíz