RandomAccessFile 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.

Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.

[Android.Runtime.Register("java/io/RandomAccessFile", DoNotGenerateAcw=true)]
public class RandomAccessFile : Java.Lang.Object, IDisposable, Java.Interop.IJavaPeerable, Java.IO.ICloseable, Java.IO.IDataInput, Java.IO.IDataOutput

[<Android.Runtime.Register("java/io/RandomAccessFile", DoNotGenerateAcw=true)>]
type RandomAccessFile = class
    inherit Object
    interface ICloseable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable
    interface IDataInput
    interface IDataOutput

Héritage: Object

Object
RandomAccessFile

Attributs: RegisterAttribute

Implémente: IJavaObject IJavaPeerable ICloseable IDataInput IDataOutput IDisposable

Remarques

Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire. Un fichier d’accès aléatoire se comporte comme un grand tableau d’octets stockés dans le système de fichiers. Il existe un type de curseur ou d’index dans le tableau implicite, appelé pointeur <<de fichier em>/ em> ; les opérations d’entrée lisent les octets à partir du pointeur de fichier et avancent le pointeur de fichier au-delà des octets lus. Si le fichier d’accès aléatoire est créé en mode lecture/écriture, les opérations de sortie sont également disponibles ; Les opérations de sortie écrivent des octets à partir du pointeur de fichier et avancent le pointeur de fichier au-delà des octets écrits. Les opérations de sortie qui écrivent au-delà de la fin actuelle du tableau implicite entraînent l’extension du tableau. Le pointeur de fichier peut être lu par la getFilePointer méthode et défini par la seek méthode.

Il est généralement vrai de toutes les routines de lecture de cette classe que si la fin du fichier est atteinte avant que le nombre souhaité d’octets ait été lu, un EOFException (qui est un type de IOException) est levée. Si un octet ne peut pas être lu pour une raison autre que la fin du fichier, un IOException autre que EOFException celui-ci est levée. En particulier, une IOException exception peut être levée si le flux a été fermé.

Ajouté dans JDK1.0.

Documentation Java pour java.io.RandomAccessFile.

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

RandomAccessFile(File, String)	Crée un flux de fichiers d’accès aléatoire à lire et éventuellement à écrire dans, le fichier spécifié par l’argument `File` .
RandomAccessFile(IntPtr, JniHandleOwnership)	Constructeur utilisé lors de la création de représentations managées d’objets JNI ; appelée par le runtime.
RandomAccessFile(String, String)	Crée un flux de fichiers d’accès aléatoire à lire et éventuellement pour écrire dans un fichier portant le nom spécifié.

Propriétés

Channel	Retourne l’objet unique `java.nio.channels.FileChannel FileChannel` associé à ce fichier.
Class	Retourne la classe runtime de ce `Object`. (Hérité de Object)
FD	Retourne l’objet de descripteur de fichier opaque associé à ce flux.
FilePointer	Retourne le décalage actuel dans ce fichier.
Handle	Handle de l’instance Android sous-jacente. (Hérité de Object)
JniIdentityHashCode	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire. (Hérité de Object)
JniPeerMembers	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
PeerReference	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire. (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

Clone()	Crée et retourne une copie de cet objet. (Hérité de Object)
Close()	Ferme ce flux de fichiers d’accès aléatoire et libère toutes les ressources système associées au flux.
Dispose()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire. (Hérité de Object)
Dispose(Boolean)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire. (Hérité de Object)
Equals(Object)	Indique si un autre objet est « égal à » celui-ci. (Hérité de Object)
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)
Length()	Retourne la longueur de ce fichier.
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)
Read()	Lit un octet de données à partir de ce fichier.
Read(Byte[])	Lit jusqu’à `b.length` des octets de données de ce fichier dans un tableau d’octets.
Read(Byte[], Int32, Int32)	Lit jusqu’à `len` des octets de données de ce fichier dans un tableau d’octets.
ReadAsync()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadAsync(Byte[])	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadAsync(Byte[], Int32, Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadBoolean()	Lit un `boolean` fichier à partir de ce fichier.
ReadBooleanAsync()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadByte()	Lit une valeur de huit bits signée à partir de ce fichier.
ReadByteAsync()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadChar()	Lit un caractère à partir de ce fichier.
ReadCharAsync()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadDouble()	Lit un `double` fichier à partir de ce fichier.
ReadDoubleAsync()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadFloat()	Lit un `float` fichier à partir de ce fichier.
ReadFloatAsync()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadFully(Byte[])	Lit les octets de ce fichier dans le tableau d’octets `b.length` , en commençant par le pointeur de fichier actuel.
ReadFully(Byte[], Int32, Int32)	Lit exactement `len` les octets de ce fichier dans le tableau d’octets, en commençant par le pointeur de fichier actuel.
ReadFullyAsync(Byte[])	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadFullyAsync(Byte[], Int32, Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadInt()	Lit un entier 32 bits signé à partir de ce fichier.
ReadIntAsync()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadLine()	Lit la ligne de texte suivante à partir de ce fichier.
ReadLineAsync()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadLong()	Lit un entier 64 bits signé à partir de ce fichier.
ReadLongAsync()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadShort()	Lit un numéro 16 bits signé à partir de ce fichier.
ReadShortAsync()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadUnsignedByte()	Lit un nombre huit bits non signé à partir de ce fichier.
ReadUnsignedByteAsync()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadUnsignedShort()	Lit un nombre 16 bits non signé à partir de ce fichier.
ReadUnsignedShortAsync()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadUTF()	Lit dans une chaîne de ce fichier.
ReadUTFAsync()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
Seek(Int64)	Définit le décalage de pointeur de fichier, mesuré à partir du début de ce fichier, auquel se produit la lecture ou l’écriture suivante.
SetHandle(IntPtr, JniHandleOwnership)	Définit la propriété Handle. (Hérité de Object)
SetLength(Int64)	Définit la longueur de ce fichier.
SkipBytes(Int32)	Tente d’ignorer les `n` octets d’entrée en ignorant les octets ignorés.
SkipBytesAsync(Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ToArray<T>()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire. (Hérité de Object)
ToString()	Retourne une représentation de chaîne de l'objet. (Hérité de Object)
UnregisterFromRuntime()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire. (Hérité de Object)
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 fichier, en commençant par le pointeur de fichier actuel.
Write(Byte[], Int32, Int32)	Écrit des `len` octets du tableau d’octets spécifié à partir du décalage `off` dans ce fichier.
Write(Int32)	Écrit l’octet spécifié dans ce fichier.
WriteAsync(Byte[])	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteAsync(Byte[], Int32, Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteAsync(Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteBoolean(Boolean)	Écrit un `boolean` fichier sous forme de valeur d’un octet.
WriteBooleanAsync(Boolean)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteByte(Int32)	Écrit un `byte` fichier sous forme de valeur d’un octet.
WriteByteAsync(Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteBytes(String)	Écrit la chaîne dans le fichier sous la forme d’une séquence d’octets.
WriteBytesAsync(String)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteChar(Int32)	Écrit un `char` fichier sous la forme d’une valeur à deux octets, octets élevés en premier.
WriteCharAsync(Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteChars(String)	Écrit une chaîne dans le fichier sous la forme d’une séquence de caractères.
WriteCharsAsync(String)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteDouble(Double)	Convertit l’argument double en une `long` méthode dans la `doubleToLongBits` classe `Double`, puis écrit cette `long` valeur dans le fichier sous la forme d’une quantité de huit octets, octets élevés en premier.
WriteDoubleAsync(Double)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteFloat(Single)	Convertit l’argument float en une `int` méthode dans la `floatToIntBits` classe `Float`, puis écrit cette `int` valeur dans le fichier sous la forme d’une quantité de quatre octets, octets élevés en premier.
WriteFloatAsync(Single)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteInt(Int32)	Écrit un `int` fichier sous la forme de quatre octets, octets élevés en premier.
WriteIntAsync(Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteLong(Int64)	Écrit un `long` fichier sous la forme de huit octets, octets élevés en premier.
WriteLongAsync(Int64)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteShort(Int32)	Écrit un `short` fichier sous la forme de deux octets, octets élevés en premier.
WriteShortAsync(Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteUTF(String)	Écrit une chaîne dans le fichier à l’aide de l’encodage UTF-8 modifié de manière indépendante de l’ordinateur.
WriteUTFAsync(String)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.

Implémentations d’interfaces explicites

IJavaPeerable.Disposed()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire. (Hérité de Object)
IJavaPeerable.DisposeUnlessReferenced()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire. (Hérité de Object)
IJavaPeerable.Finalized()	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire. (Hérité de Object)
IJavaPeerable.JniManagedPeerState	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire. (Hérité de Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire. (Hérité de Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire. (Hérité de Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire. (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)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
GetJniTypeName(IJavaPeerable)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadBooleanAsync(IDataInput)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadByteAsync(IDataInput)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadCharAsync(IDataInput)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadDoubleAsync(IDataInput)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadFloatAsync(IDataInput)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadFullyAsync(IDataInput, Byte[])	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadFullyAsync(IDataInput, Byte[], Int32, Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadIntAsync(IDataInput)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadLineAsync(IDataInput)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadLongAsync(IDataInput)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadShortAsync(IDataInput)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadUnsignedByteAsync(IDataInput)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadUnsignedShortAsync(IDataInput)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
ReadUTFAsync(IDataInput)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
SkipBytesAsync(IDataInput, Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteAsync(IDataOutput, Byte[])	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteAsync(IDataOutput, Byte[], Int32, Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteAsync(IDataOutput, Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteBooleanAsync(IDataOutput, Boolean)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteByteAsync(IDataOutput, Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteBytesAsync(IDataOutput, String)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteCharAsync(IDataOutput, Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteCharsAsync(IDataOutput, String)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteDoubleAsync(IDataOutput, Double)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteFloatAsync(IDataOutput, Single)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteIntAsync(IDataOutput, Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteLongAsync(IDataOutput, Int64)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteShortAsync(IDataOutput, Int32)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.
WriteUTFAsync(IDataOutput, String)	Les instances de cette classe prennent en charge la lecture et l’écriture dans un fichier d’accès aléatoire.

S’applique à

Partager via