logo

TechCodeview

Classe Java.io.ObjectOutputStream em Java | Conjunto 1

Um ObjectOutputStream grava tipos de dados primitivos e gráficos de objetos Java em um OutputStream. Os objetos podem ser lidos (reconstituídos) usando um ObjectInputStream. O armazenamento persistente de objetos pode ser realizado usando um arquivo para o fluxo. 

  • Somente objetos que suportam a interface java.io.Serializable podem ser gravados em fluxos. A classe de cada objeto serializável é codificada incluindo o nome da classe e a assinatura da classe, os valores dos campos e matrizes do objeto e o fechamento de quaisquer outros objetos referenciados a partir dos objetos iniciais.
  • O Java ObjectOutputStream é frequentemente usado junto com um Java ObjectInputStream. O ObjectOutputStream é usado para escrever os objetos Java e o ObjectInputStream é usado para ler os objetos novamente. 

Construtores:   

    ObjectOutputStream() protegido:Forneça uma maneira para que as subclasses que estão reimplementando ObjectOutputStream completamente não precisem alocar dados privados usados ​​apenas por esta implementação de ObjectOutputStream.ObjectOutputStream(Saída OutputStream):Cria um ObjectOutputStream que grava no OutputStream especificado. 

Métodos:   



    annotateClass nulo protegido (Classe cl):As subclasses podem implementar este método para permitir que os dados da classe sejam armazenados no fluxo. Por padrão, este método não faz nada. O método correspondente em ObjectInputStream é resolveClass. Este método é chamado exatamente uma vez para cada classe exclusiva no fluxo. O nome da classe e a assinatura já terão sido gravados no stream. Este método pode fazer uso gratuito do ObjectOutputStream para salvar qualquer representação da classe que considere adequada (por exemplo, os bytes do arquivo da classe). O método resolveClass na subclasse correspondente de ObjectInputStream deve ler e usar quaisquer dados ou objetos escritos por 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();  } }

Saída :  

A
    protegido void anotarProxyClass (Classe cl):As subclasses podem implementar esse método para armazenar dados personalizados no fluxo junto com descritores para classes de proxy dinâmico. Este método é chamado exatamente uma vez para cada descritor de classe proxy exclusivo no fluxo. A implementação padrão deste método em ObjectOutputStream não faz nada.
    O método correspondente em ObjectInputStream é resolveProxyClass. Para uma determinada subclasse de ObjectOutputStream que substitui este método, o método resolveProxyClass na subclasse correspondente de ObjectInputStream deve ler quaisquer dados ou objetos escritos por 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();  } }

Saída :  

A
    void fechar():Fecha o fluxo.Este método deve ser chamado para liberar quaisquer recursos associados ao fluxo. 
  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();  } }
    Saída : 
3
    void defaultWriteObject() :Escreva os campos não estáticos e não transitórios da classe atual neste fluxo. Isso só pode ser chamado a partir do método writeObject da classe que está sendo serializada. Ele lançará NotActiveException se for chamado de outra forma. 
  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();  }  }  }

Saída :  

A
    dreno vazio protegido():Drene todos os dados armazenados em buffer em ObjectOutputStream. Semelhante ao flush, mas não propaga o flush para o fluxo subjacente. 
  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();  } }
    enableReplaceObject booleano protegido (habilitação booleana):Habilite o fluxo para fazer a substituição de objetos no fluxo. Quando habilitado, o método replaceObject é chamado para cada objeto sendo serializado. 
    Se enable for verdadeiro e houver um gerenciador de segurança instalado, este método primeiro chama o método checkPermission do gerenciador de segurança com uma permissão SerializablePermission('enableSubstitution') para garantir que está tudo bem para permitir que o fluxo faça a substituição de objetos no fluxo. 
  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();  } }

Saída :  

false A
    ObjectOutputStream.PutField putFields():Recuperar o objeto usado para armazenar em buffer campos persistentes a serem gravados no fluxo. Os campos serão gravados no fluxo quando o método writeFields for chamado. 
  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();  } }

Saída :  

comando de instalação npm 
A
    Objeto protegido substituirObject (Objeto obj):Este método permitirá que subclasses confiáveis ​​de ObjectOutputStream substituam um objeto por outro durante a serialização. A substituição de objetos fica desabilitada até que enableReplaceObject seja chamado. O método enableReplaceObject verifica se o fluxo que solicita a substituição é confiável. A primeira ocorrência de cada objeto gravado no fluxo de serialização é passada para replaceObject. As referências subsequentes ao objeto são substituídas pelo objeto retornado pela chamada original para replaceObject. Para garantir que o estado privado dos objetos não seja exposto involuntariamente, apenas fluxos confiáveis ​​podem usar replaceObject. 
    Este método é chamado apenas uma vez quando cada objeto é encontrado pela primeira vez. Todas as referências subsequentes ao objeto serão redirecionadas para o novo objeto. Este método deve retornar o objeto a ser substituído ou o objeto original.
    Null pode ser retornado como o objeto a ser substituído, mas pode causar NullReferenceException em classes que contêm referências ao objeto original, pois podem estar esperando um objeto em vez 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 
//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();  } }

Saída :  

GeeksforGeeks
    void useProtocolVersion (versão int):Especifique a versão do protocolo de fluxo a ser usada ao gravar o fluxo. Essa rotina fornece um gancho para permitir que a versão atual da serialização grave em um formato compatível com versões anteriores de uma versão anterior do formato de fluxo.
    Serão feitos todos os esforços para evitar a introdução de incompatibilidades retroativas adicionais; no entanto, às vezes não há outra 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();  } }

Saída :  

GeeksforGeeks

Próximo artigo: Classe Java.io.ObjectOutputStream em Java | Conjunto 2


 

Criar questionário