Classe Java ObjectInputStream

Neste tutorial, vamos aprender o Java ObjectOutputStream e seus métodos por meio de exemplos.

A classe ObjectInputStream do pacote java.io pode ser usada para ler os objetos escritos anteriormente pelo ObjectOutputStream.

Ele realizou a abstração de InputStream.

Antes de aprender a classe ObjectInputStream, certifique-se de que você entendaClasse ObjectOutputStream.

O funcionamento do ObjectInputStream

ObjectInputStream é usado principalmente para ler os dados escritos por ObjectOutputStream.

Basicamente, ObjectOutputStream converte objetos Java para o fluxo correspondente. Isso é chamado de serialização. Esses fluxos convertidos podem ser armazenados em arquivos ou transmitidos pela rede.

Agora, se precisarmos ler esses objetos, usaremos ObjectInputStream, que convertirá o fluxo de volta para o objeto correspondente. Isso é chamado de desserialização.

Criar um ObjectInputStream

Para criar um fluxo de entrada de objeto, devemos primeiro importar o pacote java.io.ObjectInputStream. Após a importação do pacote, podemos criar o fluxo de entrada.

//Criar um fluxo de entrada de arquivo associado ao arquivo especificado
FileInputStream fileStream = new FileInputStream(String file);
//Criar um fluxo de entrada de objetos usando o fluxo de entrada de arquivo
ObjectInputStream objStream = new ObjectInputStream(fileStream);

No exemplo acima, criamos um fluxo de entrada de objetos chamado objStream, que está ligado ao fluxo de entrada de arquivo chamado fileStream.

Agora, objStream pode ser usado para ler objetos do arquivo.

Métodos da ObjectInputStream

A classe ObjectInputStream fornece implementações de diferentes métodos que existem no InputStream.

método read()

• read() - Ler um byte de dados do fluxo de entrada

• readBoolean() - Ler dados em forma booleana

• readChar() - Ler dados em forma de caractere

• readInt() - Ler dados em forma inteira

• readObject() - Ler objetos do fluxo de entrada

Exemplo1：Java ObjectInputStream

Vamos ver como usar a classe ObjectInputStream para ler objetos criados pela classe ObjectOutputStream.

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");
　　　　　　　　　　　　ObjectOutputStream output = new ObjectOutputStream(file);
　　　　　　　　　　　　//usando ObjectOutputStream para escrever no arquivo
　　　　　　　　　　　　output.writeInt(data1);
　　　　　　　　　　　　output.writeObject(data2);
　　　　　　　　　　　　FileInputStream fileStream = new FileInputStream("file.txt");
　　　　　　　　　　　　//Criar um fluxo de entrada de objetos
　　　　　　　　　　　　ObjectInputStream objStream = new ObjectInputStream(fileStream);
　　　　　　　　　　　　//usando o método readInt()
　　　　　　　　　　　　System.out.println("Dados inteiros: ",　+　objStream.readInt());
　　　　　　　　　　　　//usando o método readObject()
　　　　　　　　　　　　System.out.println("Dados de string: ",　+　objStream.readObject());
　　　　　　　　　　　　output.close();
　　　　　　　　　　　　objStream.close();
　　　　　　　　}
　　　　　　　　catch (Exception e) {
　　　　　　　　　　　　e.getStackTrace();
　　　　　　　　}
　　　　}
}

Resultados de saída

Dados inteiros:　5
Dados de string: This is w3codebox

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

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

Exemplo2：Java ObjectInputStream

Vamos ver outro exemplo prático,

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 dog = new Dog("Tyson", "Labrador");
　　　　　　　　try {
　　　　　　　　　　　　FileOutputStream file = new FileOutputStream("file.txt");
　　　　　　　　　　　　//Criar um ObjectOutputStream
　　　　　　　　　　　　ObjectOutputStream output = new ObjectOutputStream(file);
　　　　　　　　　　　　//Escrever objeto no fluxo de saída
　　　　　　　　　　　　output.writeObject(dog);
　　　　　　　　　　　　FileInputStream fileStream = new FileInputStream("file.txt");
　　　　　　　　　　　　//Criar um ObjectInputStream
　　　　　　　　　　　　ObjectInputStream input = new ObjectInputStream(fileStream);
　　　　　　　　　　　　//Ler objeto
　　　　　　　　　　　　Dog newDog = (Dog) input.readObject();
　　　　　　　　　　　　System.out.println("Nome do cão: ",　+　newDog.name);
　　　　　　　　　　　　System.out.println("Raça de cão: ",　+　newDog.breed);
　　　　　　　　　　　　output.close();
　　　　　　　　　　　　input.close();
　　　　　　　　}
　　　　　　　　catch (Exception e) {
　　　　　　　　　　　　e.getStackTrace();
　　　　　　　　}
　　　　}
}

Resultados de saída

Nome do cão: Tyson
Raça de cão: Labrador

No exemplo acima, criamos

• 　ObjectOutputStream usa o FileOutputStream chamado file como saída
  

• 　ObjectInputStream usa o FileInputStream chamado fileStream como entrada
  

• Objeto da classe Dog dog

Aqui, usamos o fluxo de saída de objetos para escrever objetos no arquivo. E, o fluxo de entrada de objetos lê objetos do arquivo.

AtençãoClasse Dog implementa a interface Serializable. Isso é porque ObjectOutputStream só escreve objetos serializáveis no fluxo de saída.

Outros Métodos de ObjectInputStream