Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Sérialiser un objet Java dans un tableau d’octets

Écrivez un objet dans un `byte[]` et reconstruisez-le à partir d’octets de confiance produits par le même programme. Observez pourquoi les champs `transient` sont omis par défaut.

Version : Java SE 21

Syntaxe

Java SE 21 — java.io
ByteArrayOutputStream()
ObjectOutputStream(OutputStream out) throws IOException
void ObjectOutputStream.writeObject(Object obj) throws IOException
void ObjectOutputStream.flush() throws IOException
byte[] ByteArrayOutputStream.toByteArray()
ByteArrayInputStream(byte[] buf)
ObjectInputStream(InputStream in) throws IOException
Object ObjectInputStream.readObject() throws IOException, ClassNotFoundException

Dans Java SE 21, les classes de java.io permettent d’écrire et de reconstruire un objet entièrement en mémoire. Le constructeur d’ObjectOutputStream écrit l’en-tête du flux. writeObject(Object) sérialise l’objet et le graphe accessible par les références sérialisées. Le type Object du paramètre ne garantit pas la réussite : un objet à sérialiser qui n’implémente pas Serializable peut provoquer une NotSerializableException.

Après writeObject(Object), appelez flush() pour transmettre les octets en attente au flux sous-jacent sans le fermer. ByteArrayOutputStream.toByteArray() renvoie ensuite un nouveau byte[] qui ne contient qu’une copie des octets écrits. Cet appel n’expose pas le tampon interne et ne vide pas celui du flux d’objets. ByteArrayInputStream(byte[]) utilise ce tableau sans le copier.

Le constructeur d’ObjectInputStream lit l’en-tête. readObject() reconstruit l’objet et le renvoie avec le type Object ; la conversion explicite vers Profile ne vérifie le type attendu qu’après la désérialisation. Lisez les valeurs successives dans leur ordre d’écriture et avec les types correspondants. Les opérations sur les flux peuvent lever une IOException ; la lecture peut aussi lever une ClassNotFoundException si une classe requise est indisponible. Les blocs try avec ressources ferment les flux d’objets.

La sérialisation par défaut omet les champs static et transient. Lors de la reconstruction d’une classe sérialisable ordinaire, son constructeur et ses initialiseurs de champs ne s’exécutent pas : cache vaut donc null par défaut, et non warm. Lorsque les valeurs de serialVersionUID doivent être identiques, une différence provoque une InvalidClassException. Cette exigence ne s’applique ni aux classes de tableaux ni aux classes record. Un identifiant identique ne rend pas toute modification de classe compatible. Ce format d’échange n’est pas indépendant du langage. Ne désérialisez pas de données non fiables : l’exemple ne lit que les octets produits localement par le même programme.

Exemples

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serial;
import java.io.Serializable;

public class SerializationRoundTrip {
    private static final class Profile implements Serializable {
        @Serial
        private static final long serialVersionUID = 1L;

        private final String name;
        private transient String cache = "warm";

        private Profile(String name) {
            this.name = name;
        }
    }

    public static void main(String[] args)
            throws IOException, ClassNotFoundException {
        Profile original = new Profile("Ada");
        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        byte[] bytes;
        try (ObjectOutputStream out = new ObjectOutputStream(buffer)) {
            out.writeObject(original);
            out.flush();
            bytes = buffer.toByteArray();
        }

        Profile restored;
        try (ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
            restored = (Profile) in.readObject();
        }

        System.out.println("before: " + original.name + ", cache=" + original.cache);
        System.out.println("after: " + restored.name + ", cache=" + restored.cache);
    }
}

Résultat

before: Ada, cache=warm
after: Ada, cache=null

Comparez `before` et `after` : `name` reste `Ada`, mais `cache` vaut `warm` dans l’original et `null` dans l’objet reconstruit.

Leçons associées

  • Java · Leçon 52 · Avancé · Version : 2

Sources