Java ObjectInputStream-klasse

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

De ObjectInputStream klasse van de java.io pakket kan worden gebruikt om objecten te lezen die eerder zijn geschreven door ObjectOutputStream .

Het breidt de InputStream . uit abstracte klasse.

Voordat u meer te weten komt over de ObjectInputStream class, zorg ervoor dat u op de hoogte bent van de ObjectOutputStream Class.

Werking van ObjectInputStream

De ObjectInputStream wordt voornamelijk gebruikt om gegevens te lezen die zijn geschreven door de ObjectOutputStream .

Kortom, de ObjectOutputStream converteert Java-objecten naar overeenkomstige streams. Dit staat bekend als serialisatie. Die geconverteerde streams kunnen worden opgeslagen in bestanden of worden overgedragen via netwerken.

Als we die objecten nu moeten lezen, gebruiken we de ObjectInputStream dat zal de streams terug converteren naar overeenkomstige objecten. Dit staat bekend als deserialisatie.

Maak een ObjectInputStream

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

// Creates a file input stream linked with the specified file
FileInputStream fileStream = new FileInputStream(String file);

// Creates an object input stream using the file input stream
ObjectInputStream objStream = new ObjectInputStream(fileStream);

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

Nu, de objStream kan worden gebruikt om objecten uit het bestand te lezen.

Methoden van ObjectInputStream

De ObjectInputStream class biedt implementaties van verschillende methoden die aanwezig zijn in de InputStream klasse.

read() Methode

• read() - leest een byte aan gegevens uit de invoerstroom
• readBoolean() - leest gegevens in booleaanse vorm
• readChar() - leest gegevens in tekenvorm
• readInt() - leest gegevens in geheel getal
• readObject() - leest het object uit de invoerstroom

Voorbeeld 1:Java ObjectInputStream

Laten we eens kijken hoe we de ObjectInputStream . kunnen gebruiken class om objecten te lezen die zijn geschreven door de ObjectOutputStream klasse.

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");
            ObjectOutputStream output = new ObjectOutputStream(file);

            // Writing to the file using ObjectOutputStream
            output.writeInt(data1);
            output.writeObject(data2);

            FileInputStream fileStream = new FileInputStream("file.txt");
            // Creating an object input stream
            ObjectInputStream objStream = new ObjectInputStream(fileStream);

            //Using the readInt() method
            System.out.println("Integer data :" + objStream.readInt());

            // Using the readObject() method
            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 en readObject() methode om integer data en object data uit het bestand 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 ObjectInputStream

Laten we nog een praktisch voorbeeld bekijken,

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 dog = new Dog("Tyson", "Labrador");

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

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

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

            FileInputStream fileStream = new FileInputStream("file.txt");

            // Creates an ObjectInputStream
            ObjectInputStream input = new ObjectInputStream(fileStream);

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

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

            output.close();
            input.close();
        }

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

Uitvoer

Dog Name: Tyson
Dog Breed: Labrador

In het bovenstaande voorbeeld hebben we

• ObjectOutputStream genaamd uitvoer met behulp van de FileOutputStream genaamd bestand
• ObjectInputStream genaamd invoer met behulp van de FileInputStream genaamd fileStream
• Een object hond 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 de serialiseerbare objecten naar de uitvoerstroom.

Andere methoden van ObjectInputStream

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