Classe Java ObjectOutputStream

Neste tutorial, vamos aprender sobre Java ObjectOutputStream e seus métodos com a ajuda de exemplos.

A classe ObjectOutputStream do pacote java.io pode ser usada para escrever objetos que podem ser lidos pelo ObjectInputStream.

Ele herda a classe abstrata OutputStream.

Princípio de funcionamento do ObjectOutputStream

Basicamente, ObjectOutputStream codifica objetos Java usando nomes de classe e valores de objetos. Portanto, gera os fluxos correspondentes. Este processo é chamado de serialização.

Esses fluxos convertidos podem ser armazenados em arquivos e transmitidos entre redes.

Attention：A classe ObjectOutputStream escreve apenas os objetos que implementam a interface Serializable. Isso porque os objetos precisam ser serializados ao serem escritos no fluxo.

Criar um ObjectOutputStream

Para criar um fluxo de saída de objetos, devemos primeiro importar o pacote java.io.ObjectOutputStream. Após a importação do pacote, podemos criar o fluxo de saída.

//Criar um FileOutputStream, onde escreve objetos no ObjectOutputStream
FileOutputStream fileStream = new FileOutputStream(String file);
//Criar ObjectOutputStream
ObjectOutputStream objStream = new ObjectOutputStream(fileStream);

No exemplo acima, criamos um objeto de fluxo de saída de objetos chamado objStream, que está ligado ao fluxo de saída de arquivo chamado fileStream.

Métodos da ObjectOutputStream

A classe ObjectOutputStream fornece implementações para diferentes métodos da classe OutputStream.

Método write()

• write() - Escrever dados de bytes no fluxo de saída

• writeBoolean() - Escrever dados em forma booleana

• writeChar() - Escrever dados em forma de caractere

• writeInt() - Escrever dados em forma inteira

• writeObject() - Escrever objeto no fluxo de saída

Exemplo1Java ObjectOutputStream

Vamos ver como usar ObjectOutputStream para armazenar objetos em um arquivo e como usar ObjectInputStream para ler esses objetos do arquivo

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　int data1　=　5;
　　　　　　　　String data2　= "This is w3codebox;
　　　　　　　　try {
　　　　　　　　　　　　FileOutputStream file = new FileOutputStream("file.txt");
　　　　　　　　　　　　//Criar um ObjectOutputStream
　　　　　　　　　　　　ObjectOutputStream output = new ObjectOutputStream(file);
　　　　　　　　　　　　//Escrever objeto no fluxo de saída
　　　　　　　　　　　　output.writeInt(data1);
　　　　　　　　　　　　output.writeObject(data2);
　　　　　　　　　　　　//Lendo dados usando ObjectInputStream
　　　　　　　　　　　　FileInputStream fileStream = new FileInputStream("file.txt");
　　　　　　　　　　　　ObjectInputStream objStream = new ObjectInputStream(fileStream);
　　　　　　　　　　　　System.out.println("Integer data:");　+　objStream.readInt());
　　　　　　　　　　　　System.out.println("String data: ");　+　objStream.readObject());
　　　　　　　　　　　　output.close();
　　　　　　　　　　　　objStream.close();
　　　　　　　　}
　　　　　　　　catch (Exception e) {
　　　　　　　　　　　　e.getStackTrace();
　　　　　　　　}
　　　　}
}

Output Result

Integer data:　5
String data: This is w3codebox

No exemplo acima, usamos os métodos readInt() e readObject() para ler dados inteiros e dados de objetos do arquivo.

Aqui, usamos ObjectOutputStream para escrever dados em um arquivo. Em seguida, usamos ObjectInputStream para ler dados do arquivo.

Exemplo2Java ObjectOutputStream

Outro exemplo

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class Dog implements Serializable {
　　　　String name;
　　　　String breed;
　　　　public Dog(String name, String breed) {
　　　　　　　　this.name = name;
　　　　　　　　this.breed = breed;
　　　　}
}
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Criar um objeto da classe Dog
　　　　　　　　Dog dog1　= new Dog("泰里", "Labrador猎犬");
　　　　　　　　try {
　　　　　　　　　　　　FileOutputStream fileOut = new FileOutputStream("file.txt");
　　　　　　　　　　　　//Criar um ObjectOutputStream
　　　　　　　　　　　　ObjectOutputStream objOut = new ObjectOutputStream(fileOut);
　　　　　　　　　　　　//Escrever objeto no fluxo de saída
　　　　　　　　　　　　objOut.writeObject(dog1);
　　　　　　　　　　　　//Ler objeto
　　　　　　　　　　　　FileInputStream fileIn = new FileInputStream("file.txt");
　　　　　　　　　　　　ObjectInputStream objIn = new ObjectInputStream(fileIn);
　　　　　　　　　　　　//　Ler objeto
　　　　　　　　　　　　Dog newDog = (Dog) objIn.readObject();
　　　　　　　　　　　　System.out.println("Nome do cão: ");　+　newDog.name);
　　　　　　　　　　　　System.out.println("Espécie de cão: ");　+　newDog.breed);
　　　　　　　　　　　　objOut.close();
　　　　　　　　　　　　objIn.close();
　　　　　　　　}
　　　　　　　　catch (Exception e) {
　　　　　　　　　　　　e.getStackTrace();
　　　　　　　　}
　　　　}
}

Output Result

Dog name: Terry
Dog breed: Labrador Retriever

In the above example, we created

• 　The ObjectOutputStream named objOut uses the FileOutputStream named fileOut.

• 　The ObjectInputStream named objIn uses the FileInputStream named fileIn.
  

• The object of the Dog class dog1.

Here, we then use the object output stream to write objects to the file. And, the object input stream reads objects from the file.

AttentionNote: The Dog class implements the Serializable interface. This is because ObjectOutputStream only writes objects that can be serialized into the output stream.

Other Methods of ObjectOutputStream