Java ObjectOutputStream-klasse

Verkent de Java ObjectOutputStream API, de kernmethoden en stapsgewijze voorbeelden die demonstreren hoe je objecten naar bestanden serialiseert en ze terugleest.

Inleiding

De ObjectOutputStream-klasse uit het java.io-pakket laat je Java-objecten schrijven zodat ze later door ObjectInputStream gelezen kunnen worden. Het breidt OutputStream uit en is de ruggengraat van Java's ingebouwde serialisatiemechanisme.

Hoe ObjectOutputStream werkt

Wanneer je een object naar een ObjectOutputStream schrijft, codeert het framework de klassenaam, veldwaarden en type-informatie in een binair formaat – een proces bekend als serialisatie. De resulterende bytestream kan in een bestand opgeslagen, via een netwerk verzonden, of zelfs in geheugen ingebed worden.

Belangrijk: Alleen objecten die java.io.Serializable implementeren kunnen geserialiseerd worden. Deze interface fungeert als marker om de runtime te informeren dat een object veilig is om te persisteren of te transporteren.

Een ObjectOutputStream aanmaken

Begin met het importeren van de klasse:

import java.io.ObjectOutputStream;

Koppel het vervolgens aan een FileOutputStream of een andere onderliggende OutputStream:

// Schrijf naar een bestand genaamd "data.bin"
FileOutputStream fileStream = new FileOutputStream("data.bin");
ObjectOutputStream objStream = new ObjectOutputStream(fileStream);

Hier is objStream nu klaar om objecten te serialiseren in fileStream.

Kernmethoden van ObjectOutputStream

De klasse erft een suite methoden van OutputStream en voegt gespecialiseerde toe voor objectafhandeling:

• write(int b) – schrijft een enkele byte
• writeBoolean(boolean v) – schrijft een boolean-waarde
• writeChar(int v) – schrijft een karakter
• writeInt(int v) – schrijft een integer
• writeObject(Object obj) – serialiseert het gegeven object

Voorbeeld 1: Primitieven en String-data serialiseren

Hieronder een compleet snippet dat een int en een String naar een bestand schrijft, en ze daarna terugleest met ObjectInputStream:

import java.io.*;

public class Main {
    public static void main(String[] args) {
        int data1 = 5;
        String data2 = "Dit is programiz";
        try {
            // Objecten schrijven
            FileOutputStream fos = new FileOutputStream("bestand.bin");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeInt(data1);
            oos.writeObject(data2);
            oos.close();
            // Objecten lezen
            FileInputStream fis = new FileInputStream("bestand.bin");
            ObjectInputStream ois = new ObjectInputStream(fis);
            System.out.println("Integer data: " + ois.readInt());
            System.out.println("String data: " + ois.readObject());
            ois.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Output

Integer data: 5
String data: Dit is programiz

Voorbeeld 2: Een aangepast object serialiseren

Om een door de gebruiker gedefinieerde klasse te serialiseren, implementeer gewoon Serializable:

import java.io.*;

class Hond implements Serializable {
    String naam;
    String ras;
    Hond(String naam, String ras) {
        this.naam = naam;
        this.ras = ras;
    }
}

public class Main {
    public static void main(String[] args) {
        Hond hond1 = new Hond("Tyson", "Labrador");
        try {
            // Het object schrijven
            FileOutputStream fos = new FileOutputStream("hond.bin");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(hond1);
            oos.close();
            // Het object lezen
            FileInputStream fis = new FileInputStream("hond.bin");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Hond nieuweHond = (Hond) ois.readObject();
            System.out.println("Hond naam: " + nieuweHond.naam);
            System.out.println("Hond ras: " + nieuweHond.ras);
            ois.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Output

Hond naam: Tyson
Hond ras: Labrador

De Hond-klasse moet Serializable implementeren omdat ObjectOutputStream alleen serialiseerbare objecten kan schrijven.

Extra ObjectOutputStream-operaties

Voor een diepere duik, raadpleeg de officiële Java-documentatie.