Classe Java ObjectOutputStream

In questo tutorial, impareremo attraverso esempi Java ObjectOutputStream e i suoi metodi.

La classe ObjectOutputStream del pacchetto java.io può essere utilizzata per scrivere oggetti che possono essere letti da ObjectInputStream.

Eredita l'astrazione OutputStream.

Principio di funzionamento di ObjectOutputStream

In sostanza, ObjectOutputStream codifica gli oggetti Java utilizzando il nome della classe e i valori degli oggetti. Pertanto, viene generato lo stream corrispondente. Questo processo si chiama serializzazione.

Questi stream convertiti possono essere memorizzati nei file e trasportati tra reti.

AttenzioneLa classe ObjectOutputStream scrive solo gli oggetti che implementano l'interfaccia Serializable. Questo è perché gli oggetti devono essere serializzati quando vengono scritti nello stream.

Creazione di un ObjectOutputStream

Per creare un output stream di oggetti, dobbiamo prima importare il pacchetto java.io.ObjectOutputStream. Dopo aver importato il pacchetto, possiamo creare lo stream di output.

//Creazione di un FileOutputStream, dove viene scritto l'oggetto in ObjectOutputStream
FileOutputStream fileStream = new FileOutputStream(String file);
//Creazione di ObjectOutputStream
ObjectOutputStream objStream = new ObjectOutputStream(fileStream);

Nell'esempio sopra, abbiamo creato un oggetto output stream chiamato objStream, che è collegato all'output stream di file chiamato fileStream.

Metodi di ObjectOutputStream

La classe ObjectOutputStream fornisce implementazioni per diversi metodi presenti nella classe OutputStream.

Metodo write()

• write() - Scrivi dati in formato byte nell'output stream

• writeBoolean() - Scrivi dati come booleano

• writeChar() - Scrivi dati come carattere

• writeInt() - Scrivi dati come intero

• writeObject() - Scrivi un oggetto nell'output stream

Esempio 1: Java ObjectOutputStream

Vediamo come utilizzare ObjectOutputStream per memorizzare oggetti in un file e come utilizzare ObjectInputStream per leggere questi oggetti dal file

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
　　　　　　　　　　　　ObjectOutputStream output = new ObjectOutputStream(file);
　　　　　　　　　　　　// 将对象写入输出流
　　　　　　　　　　　　output.writeInt(data1);
　　　　　　　　　　　　output.writeObject(data2);
　　　　　　　　　　　　//Leggi dati utilizzando 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();
　　　　　　　　}
　　　　}
}

Risultato di output

Integer data: 5
String data: This is w3codebox

Nel esempio sopra, abbiamo utilizzato i metodi readInt() e readObject() per leggere dati interi e oggetti dal file.

Qui utilizziamo ObjectOutputStream per scrivere dati nel file. Poi utilizziamo ObjectInputStream per leggere dati dal file.

Esempio 2: Java ObjectOutputStream

Di nuovo un esempio

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) {
　　　　　　　　// 创建一个Dog类的对象
　　　　　　　　Dog dog1 = new Dog("泰里", "拉布拉多猎犬");
　　　　　　　　try {
　　　　　　　　　　　　FileOutputStream fileOut = new FileOutputStream("file.txt");
　　　　　　　　　　　　// 创建一个ObjectOutputStream
　　　　　　　　　　　　ObjectOutputStream objOut = new ObjectOutputStream(fileOut);
　　　　　　　　　　　　// 将对象写入输出流
　　　　　　　　　　　　objOut.writeObject(dog1);
　　　　　　　　　　　　// 读取对象
　　　　　　　　　　　　FileInputStream fileIn = new FileInputStream("file.txt");
　　　　　　　　　　　　ObjectInputStream objIn = new ObjectInputStream(fileIn);
　　　　　　　　　　　　// 读取对象
　　　　　　　　　　　　Dog newDog = (Dog) objIn.readObject();
　　　　　　　　　　　　System.out.println("狗名: 	" + newDog.name);
　　　　　　　　　　　　System.out.println("犬種: 	" + newDog.breed);
　　　　　　　　　　　　objOut.close();
　　　　　　　　　　　　objIn.close();
　　　　　　　　}
　　　　　　　　catch (Exception e) {
　　　　　　　　　　　　e.getStackTrace();
　　　　　　　　}
　　　　}
}

Risultato di output

Nome del cane:　Terry
Razza:　Labrador Retriever

Nell'esempio sopra, abbiamo creato

• 　Un ObjectOutputStream chiamato objOut utilizza un FileOutputStrea chiamato fileOut.

• 　Un ObjectInputStream chiamato objIn utilizza un FileInputStream chiamato fileIn.
  

• Oggetto della classe Dog dog1.

Qui, quindi, utilizziamo lo stream di output degli oggetti per scrivere oggetti nel file. E lo stream di input degli oggetti legge oggetti dal file.

Attenzione：La classe Dog implementa l'interfaccia Serializable. Questo perché ObjectInputStream scrive solo gli oggetti che possono essere serializzati nel flusso di output.

Altri metodi di ObjectOutputStream