Classe Java ObjectOutputStream

Dans ce didacticiel, nous allons découvrir Java ObjectOutputStream et ses méthodes à l'aide d'exemples.

Le ObjectOutputStream classe des java.io package peut être utilisé pour écrire des objets qui peuvent être lus par ObjectInputStream .

Il étend le OutputStream classe abstraite.

Fonctionnement d'ObjectOutputStream

En gros, le ObjectOutputStream encode les objets Java à l'aide du nom de classe et des valeurs d'objet. Et, génère donc des flux correspondants. Ce processus est connu sous le nom de sérialisation.

Ces flux convertis peuvent être stockés dans des fichiers et peuvent être transférés entre les réseaux.

Remarque :Le ObjectOutputStream la classe n'écrit que les objets qui implémentent le Serializable interface. En effet, les objets doivent être sérialisés lors de l'écriture dans le flux

Créer un ObjectOutputStream

Afin de créer un flux de sortie d'objet, nous devons importer le java.io.ObjectOutputStream paquet d'abord. Une fois le package importé, voici comment créer un flux de sortie.

// Creates a FileOutputStream where objects from ObjectOutputStream are written
FileOutputStream fileStream = new FileOutputStream(String file);

// Creates the ObjectOutputStream
ObjectOutputStream objStream = new ObjectOutputStream(fileStream);

Dans l'exemple ci-dessus, nous avons créé un flux de sortie d'objet nommé objStream qui est lié au flux de sortie de fichier nommé fileStream .

Méthodes d'ObjectOutputStream

Le ObjectOutputStream la classe fournit des implémentations pour différentes méthodes présentes dans le OutputStream classe.

méthode write()

write() - écrit un octet de données dans le flux de sortie
writeBoolean() - écrit les données sous forme booléenne
writeChar() - écrit les données sous forme de caractères
writeInt() - écrit les données sous forme entière
writeObject() - écrit l'objet dans le flux de sortie

Exemple 1 :Java ObjectOutputStream

Voyons comment nous pouvons utiliser ObjectOutputStream pour stocker des objets dans un fichier et ObjectInputStream pour lire ces objets à partir des fichiers

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 programiz";

        try {

            FileOutputStream file = new FileOutputStream("file.txt");

            // Creates an ObjectOutputStream
            ObjectOutputStream output = new ObjectOutputStream(file);

            // writes objects to output stream
            output.writeInt(data1);
            output.writeObject(data2);

            // Reads data using the 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();
        }
    }
}

Sortie

Integer data: 5
String data: This is programiz

Dans l'exemple ci-dessus, nous avons utilisé le readInt() méthode et readObject() méthode pour lire des données entières et des données d'objet à partir des fichiers.

Ici, nous avons utilisé le ObjectOutputStream pour écrire des données dans le fichier. Nous lisons ensuite les données du fichier en utilisant le ObjectInputStream .

Exemple 2 :Java ObjectOutputStream

Prenons un autre exemple,

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) {

        // Creates an object of Dog class
        Dog dog1 = new Dog("Tyson", "Labrador");

        try {
            FileOutputStream fileOut = new FileOutputStream("file.txt");

            // Creates an ObjectOutputStream
            ObjectOutputStream objOut = new ObjectOutputStream(fileOut);

            // Writes objects to the output stream
            objOut.writeObject(dog1);

            // Reads the object
            FileInputStream fileIn = new FileInputStream("file.txt");
            ObjectInputStream objIn = new ObjectInputStream(fileIn);

            // Reads the objects
            Dog newDog = (Dog) objIn.readObject();

            System.out.println("Dog Name: " + newDog.name);
            System.out.println("Dog Breed: " + newDog.breed);

            objOut.close();
            objIn.close();
        }

        catch (Exception e) {
            e.getStackTrace();
        }
    }
}

Sortie

Dog Name: Tyson
Dog Breed: Labrador

Dans l'exemple ci-dessus, nous avons créé

ObjectOutputStream nommé objOut en utilisant le FileOutputStream nommé fileOut
ObjectInputStream nommé objIn en utilisant le FileInputStream nommé fileIn .
Un objet chien1 du Chien classe.

Ici, nous avons ensuite utilisé le flux de sortie de l'objet pour écrire l'objet dans le fichier. Et, le flux d'entrée d'objet pour lire l'objet à partir du fichier.

Remarque :Le chien la classe implémente le Serializable interface. C'est parce que le ObjectOutputStream écrit uniquement les objets qui peuvent être sérialisés dans le flux de sortie.

Autres méthodes d'ObjectOutputStream

Méthodes	Descriptions
`flush()`	efface toutes les données du flux de sortie
`drain()`	place toutes les données mises en mémoire tampon dans le flux de sortie
`close()`	ferme le flux de sortie

Pour en savoir plus, visitez Java ObjectOutputStream (documentation officielle de Java).

Classe Java ObjectInputStream Classe Java BufferedInputStream

Java