ObjectOutputStream Classe

Référence

Définition

Espace de noms:: Java.IO

Assembly:: Mono.Android.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.

[Android.Runtime.Register("java/io/ObjectOutputStream", DoNotGenerateAcw=true)]
public class ObjectOutputStream : Java.IO.OutputStream, IDisposable, Java.Interop.IJavaPeerable, Java.IO.IObjectOutput

[<Android.Runtime.Register("java/io/ObjectOutputStream", DoNotGenerateAcw=true)>]
type ObjectOutputStream = class
    inherit OutputStream
    interface IObjectOutput
    interface IDataOutput
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Héritage: Object

Object

OutputStream
ObjectOutputStream

Attributs: RegisterAttribute

Implémente: IJavaObject IJavaPeerable IDataOutput IObjectOutput IDisposable

Remarques

Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. Les objets peuvent être lus (reconstitués) à l’aide d’un ObjectInputStream. Le stockage persistant des objets peut être effectué à l’aide d’un fichier pour le flux. Si le flux est un flux de socket réseau, les objets peuvent être reconstitués sur un autre hôte ou dans un autre processus.

Seuls les objets qui prennent en charge l’interface java.io.Serializable peuvent être écrits dans des flux. La classe de chaque objet sérialisable est encodée, y compris le nom de classe et la signature de la classe, les valeurs des champs et tableaux de l’objet, ainsi que la fermeture de tous les autres objets référencés à partir des objets initiaux.

La méthode writeObject est utilisée pour écrire un objet dans le flux. Tout objet, y compris strings et tableaux, est écrit avec writeObject. Plusieurs objets ou primitives peuvent être écrits dans le flux. Les objets doivent être lus à partir du objectInputstream correspondant avec les mêmes types et dans le même ordre qu’ils ont été écrits.

Les types de données primitifs peuvent également être écrits dans le flux à l’aide des méthodes appropriées de DataOutput. Les chaînes peuvent également être écrites à l’aide de la méthode writeUTF.

Le mécanisme de sérialisation par défaut pour un objet écrit la classe de l’objet, la signature de classe et les valeurs de tous les champs non temporaires et non statiques. Les références à d’autres objets (sauf dans des champs temporaires ou statiques) entraînent l’écriture de ces objets également. Plusieurs références à un seul objet sont encodées à l’aide d’un mécanisme de partage de référence afin que les graphiques d’objets puissent être restaurés sur la même forme que lorsque l’original a été écrit.

Par exemple, pour écrire un objet qui peut être lu par l’exemple dans ObjectInputStream : <br>

FileOutputStream fos = new FileOutputStream("t.tmp");
                 ObjectOutputStream oos = new ObjectOutputStream(fos);

                 oos.writeInt(12345);
                 oos.writeObject("Today");
                 oos.writeObject(new Date());

                 oos.close();

Les classes qui nécessitent une gestion spéciale pendant le processus de sérialisation et de désérialisation doivent implémenter des méthodes spéciales avec ces signatures exactes : <br>

private void readObject(java.io.ObjectInputStream stream)
                throws IOException, ClassNotFoundException;
            private void writeObject(java.io.ObjectOutputStream stream)
                throws IOException
            private void readObjectNoData()
                throws ObjectStreamException;

La méthode writeObject est chargée d’écrire l’état de l’objet pour sa classe particulière afin que la méthode readObject correspondante puisse la restaurer. La méthode n’a pas besoin de s’inquiéter de l’état appartenant aux superclasses ou sous-classes de l’objet. L’état est enregistré en écrivant les champs individuels dans ObjectOutputStream à l’aide de la méthode writeObject ou en utilisant les méthodes pour les types de données primitifs pris en charge par DataOutput.

La sérialisation n’écrit pas les champs d’un objet qui n’implémente pas l’interface java.io.Serializable. Les sous-classes d’objets qui ne sont pas sérialisables peuvent être sérialisables. Dans ce cas, la classe non sérialisable doit avoir un constructeur no-arg pour permettre à ses champs d’être initialisés. Dans ce cas, il incombe à la sous-classe d’enregistrer et de restaurer l’état de la classe non sérialisable. Il est fréquent que les champs de cette classe soient accessibles (public, package ou protégé) ou qu’il existe des méthodes get et set qui peuvent être utilisées pour restaurer l’état.

La sérialisation d’un objet peut être empêchée en implémentant des méthodes writeObject et readObject qui lèvent notSerializableException. L’exception est interceptée par ObjectOutputStream et abandonne le processus de sérialisation.

L’implémentation de l’interface externalisable permet à l’objet d’assumer un contrôle complet sur le contenu et le format du formulaire sérialisé de l’objet. Les méthodes de l’interface Externalizable, writeExternal et readExternal, sont appelées pour enregistrer et restaurer l’état des objets. En cas d’implémentation par une classe, ils peuvent écrire et lire leur propre état à l’aide de toutes les méthodes de ObjectOutput et ObjectInput. Il incombe aux objets de gérer tout contrôle de version qui se produit.

Les constantes enum sont sérialisées différemment des objets sérialisables ordinaires ou externalisables. La forme sérialisée d’une constante enum se compose uniquement de son nom ; les valeurs de champ de la constante ne sont pas transmises. Pour sérialiser une constante d’énumération, ObjectOutputStream écrit la chaîne retournée par la méthode de nom de la constante. Comme d’autres objets sérialisables ou externalisables, les constantes d’énumération peuvent fonctionner comme les cibles des références back qui apparaissent par la suite dans le flux de sérialisation. Le processus par lequel les constantes d’énumération sont sérialisées ne peut pas être personnalisé ; les méthodes writeObject et writeReplace spécifiques à une classe définies par les types d’énumération sont ignorées lors de la sérialisation. De même, les déclarations de champs serialPersistentFields ou serialVersionUID sont également ignorées : tous les types d’énumérations ont un serialVersionUID fixe de 0L.

Les données primitives, à l’exception des champs sérialisables et des données externalisables, sont écrites dans ObjectOutputStream dans les enregistrements de données de bloc. Un enregistrement de données de bloc est composé d’un en-tête et de données. L’en-tête de données de bloc se compose d’un marqueur et du nombre d’octets à suivre. Les écritures de données primitives consécutives sont fusionnées dans un enregistrement de données de bloc. Le facteur de blocage utilisé pour un enregistrement de données de bloc sera de 1 024 octets. Chaque enregistrement de données de bloc est rempli jusqu’à 1 024 octets ou écrit chaque fois qu’il existe une terminaison du mode de données de bloc. Les appels aux méthodes ObjectOutputStream writeObject, defaultWriteObject et writeFields terminent initialement tout enregistrement de données de bloc existant.

Ajouté dans JDK1.1.

Documentation Java pour java.io.ObjectOutputStream.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

Constructeurs

ObjectOutputStream()	Fournissez un moyen pour les sous-classes qui réexémentent complètement ObjectOutputStream de ne pas avoir à allouer des données privées uniquement utilisées par cette implémentation d’ObjectOutputStream.
ObjectOutputStream(IntPtr, JniHandleOwnership)	Constructeur utilisé lors de la création de représentations managées d’objets JNI ; appelée par le runtime.
ObjectOutputStream(Stream)	Crée un ObjectOutputStream qui écrit dans le OutputStream spécifié.

Propriétés

Class	Retourne la classe runtime de ce `Object`. (Hérité de Object)
Handle	Handle de l’instance Android sous-jacente. (Hérité de Object)
JniIdentityHashCode	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de Object)
JniPeerMembers	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
PeerReference	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de Object)
ThresholdClass	Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code.
ThresholdType	Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code.

Méthodes

AnnotateClass(Class)	Les sous-classes peuvent implémenter cette méthode pour permettre aux données de classe d’être stockées dans le flux.
AnnotateProxyClass(Class)	Les sous-classes peuvent implémenter cette méthode pour stocker des données personnalisées dans le flux, ainsi que des descripteurs pour les classes proxy dynamiques.
Clone()	Crée et retourne une copie de cet objet. (Hérité de Object)
Close()	Ferme ce flux de sortie et libère toutes les ressources système associées à ce flux. (Hérité de OutputStream)
DefaultWriteObject()	Écrivez les champs non statiques et non temporaires de la classe actuelle dans ce flux.
Dispose()	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de Object)
Dispose(Boolean)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de Object)
Drain()	Videz les données mises en mémoire tampon dans ObjectOutputStream.
EnableReplaceObject(Boolean)	Activez le flux pour effectuer le remplacement d’objets dans le flux.
Equals(Object)	Indique si un autre objet est « égal à » celui-ci. (Hérité de Object)
Flush()	Vide ce flux de sortie et force les octets de sortie mis en mémoire tampon à écrire. (Hérité de OutputStream)
GetHashCode()	Retourne une valeur de code de hachage pour l'objet. (Hérité de Object)
JavaFinalize()	Appelé par le garbage collector sur un objet lorsque le garbage collection détermine qu’il n’y a plus de références à l’objet. (Hérité de Object)
Notify()	Réveille un thread unique qui attend le moniteur de cet objet. (Hérité de Object)
NotifyAll()	Réveille tous les threads qui attendent le moniteur de cet objet. (Hérité de Object)
PutFields()	Récupérez l’objet utilisé pour mettre en mémoire tampon les champs persistants à écrire dans le flux.
ReplaceObject(Object)	Cette méthode permet aux sous-classes approuvées d’ObjectOutputStream de remplacer un objet par un autre lors de la sérialisation.
Reset()	La réinitialisation ignore l’état des objets déjà écrits dans le flux.
SetHandle(IntPtr, JniHandleOwnership)	Définit la propriété Handle. (Hérité de Object)
ToArray<T>()	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de Object)
ToString()	Retourne une représentation de chaîne de l'objet. (Hérité de Object)
UnregisterFromRuntime()	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de Object)
UseProtocolVersion(ObjectStreamProtocol)	Spécifiez la version du protocole de flux à utiliser lors de l’écriture du flux.
Wait()	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti par em ou><em>interrompu</em>.<> (Hérité de Object)
Wait(Int64)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)
Wait(Int64, Int32)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)
Write(Byte[])	Écrit des `b.length` octets du tableau d’octets spécifié dans ce flux de sortie. (Hérité de OutputStream)
Write(Byte[], Int32, Int32)	Écrit des `len` octets du tableau d’octets spécifié à partir du décalage `off` vers ce flux de sortie. (Hérité de OutputStream)
Write(Int32)	Écrit un octet.
WriteAsync(Byte[])	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de OutputStream)
WriteAsync(Byte[], Int32, Int32)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de OutputStream)
WriteAsync(Int32)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de OutputStream)
WriteBoolean(Boolean)	Écrit une valeur booléenne.
WriteByte(Int32)	Écrit un octet de 8 bits.
WriteBytes(String)	Écrit une chaîne sous la forme d’une séquence d’octets.
WriteChar(Int32)	Écrit un char 16 bits.
WriteChars(String)	Écrit une chaîne sous la forme d’une séquence de caractères.
WriteClassDescriptor(ObjectStreamClass)	Écrivez le descripteur de classe spécifié dans ObjectOutputStream.
WriteDouble(Double)	Écrit un double 64 bits.
WriteFields()	Écrivez les champs mis en mémoire tampon dans le flux.
WriteFloat(Single)	Écrit un float 32 bits.
WriteInt(Int32)	Écrit un int 32 bits.
WriteLong(Int64)	Écrit une longueur de 64 bits.
WriteObject(Object)	Écrivez l’objet spécifié dans ObjectOutputStream.
WriteObjectOverride(Object)	Méthode utilisée par les sous-classes pour remplacer la méthode writeObject par défaut.
WriteShort(Int32)	Écrit un raccourci 16 bits.
WriteStreamHeader()	La méthode writeStreamHeader est fournie afin que les sous-classes puissent ajouter ou ajouter leur propre en-tête au flux.
WriteUnshared(Object)	Écrit un objet « non partagé » dans ObjectOutputStream.
WriteUTF(String)	Écriture de données primitives de cette chaîne au format UTF-8 modifié.

Implémentations d’interfaces explicites

IJavaPeerable.Disposed()	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de Object)
IJavaPeerable.DisposeUnlessReferenced()	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de Object)
IJavaPeerable.Finalized()	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de Object)
IJavaPeerable.JniManagedPeerState	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream. (Hérité de Object)

Méthodes d’extension

JavaCast<TResult>(IJavaObject)	Effectue une conversion de type vérifiée par le runtime Android.
JavaCast<TResult>(IJavaObject)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
GetJniTypeName(IJavaPeerable)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteAsync(IDataOutput, Byte[])	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteAsync(IDataOutput, Byte[], Int32, Int32)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteAsync(IDataOutput, Int32)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteBooleanAsync(IDataOutput, Boolean)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteByteAsync(IDataOutput, Int32)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteBytesAsync(IDataOutput, String)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteCharAsync(IDataOutput, Int32)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteCharsAsync(IDataOutput, String)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteDoubleAsync(IDataOutput, Double)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteFloatAsync(IDataOutput, Single)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteIntAsync(IDataOutput, Int32)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteLongAsync(IDataOutput, Int64)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteShortAsync(IDataOutput, Int32)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteUTFAsync(IDataOutput, String)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
FlushAsync(IFlushable)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
FlushAsync(IObjectOutput)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.
WriteObjectAsync(IObjectOutput, Object)	Un ObjectOutputStream écrit des types de données primitifs et des graphiques d’objets Java dans un OutputStream.

S’applique à

Partager via