Java ObjectOutputStream-klasse

In deze zelfstudie leren we over Java ObjectOutputStream en zijn methoden met behulp van voorbeelden.

De ObjectOutputStream klasse van de java.io pakket kan worden gebruikt om objecten te schrijven die kunnen worden gelezen door ObjectInputStream .

Het verlengt de OutputStream abstracte klasse.

Werking van ObjectOutputStream

Kortom, de ObjectOutputStream codeert Java-objecten met behulp van de klassenaam en objectwaarden. En genereert dus overeenkomstige stromen. Dit proces staat bekend als serialisatie.

Die geconverteerde streams kunnen in bestanden worden opgeslagen en tussen netwerken worden overgedragen.

Opmerking :De ObjectOutputStream class schrijft alleen die objecten die de Serializable . implementeren koppel. Dit komt omdat objecten moeten worden geserialiseerd tijdens het schrijven naar de stream

Maak een ObjectOutputStream

Om een ​​objectuitvoerstroom te maken, moeten we de java.io.ObjectOutputStream . importeren pakket eerst. Zodra we het pakket hebben geïmporteerd, kunnen we als volgt een uitvoerstroom maken.

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

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

In het bovenstaande voorbeeld hebben we een objectuitvoerstroom gemaakt met de naam objStream die is gekoppeld aan de bestandsuitvoerstroom genaamd fileStream .

Methoden van ObjectOutputStream

De ObjectOutputStream class biedt implementaties voor verschillende methoden die aanwezig zijn in de OutputStream klasse.

write()-methode

• write() - schrijft een byte aan gegevens naar de uitvoerstroom
• writeBoolean() - schrijft gegevens in booleaanse vorm
• writeChar() - schrijft gegevens in tekenvorm
• writeInt() - schrijft gegevens in geheel getal
• writeObject() - schrijft object naar de uitvoerstroom

Voorbeeld 1:Java ObjectOutputStream

Laten we eens kijken hoe we ObjectOutputStream . kunnen gebruiken om objecten in een bestand op te slaan en ObjectInputStream om die objecten uit de bestanden te lezen

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();
        }
    }
}

Uitvoer

Integer data: 5
String data: This is programiz

In het bovenstaande voorbeeld hebben we de readInt() . gebruikt methode en readObject() methode om een ​​geheel getal gegevens en objectgegevens uit de bestanden te lezen.

Hier hebben we de ObjectOutputStream . gebruikt om gegevens naar het bestand te schrijven. Vervolgens lezen we de gegevens uit het bestand met behulp van de ObjectInputStream .

Voorbeeld 2:Java ObjectOutputStream

Laten we nog een voorbeeld nemen,

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();
        }
    }
}

Uitvoer

Dog Name: Tyson
Dog Breed: Labrador

In het bovenstaande voorbeeld hebben we

• ObjectOutputStream genaamd objOut met behulp van de FileOutputStream genaamd fileOut
• ObjectInputStream genaamd objIn met behulp van de FileInputStream genaamd fileIn .
• Een object dog1 van de Hond klas.

Hier hebben we vervolgens de objectuitvoerstroom gebruikt om het object naar het bestand te schrijven. En de objectinvoerstroom om het object uit het bestand te lezen.

Opmerking :De Hond class implementeert de Serializable koppel. Het is omdat de ObjectOutputStream schrijft alleen objecten die kunnen worden geserialiseerd naar de uitvoerstroom.

Andere methoden van ObjectOutputStream

Ga voor meer informatie naar Java ObjectOutputStream (officiële Java-documentatie).