Plan Des éléments de programmation en C Des éléments de programmation en C++ Des éléments de programmation en Java

Des éléments en C.

Ouverture du fichier La fonction fopen Cette fonction, de type FILE* ouvre un fichier et lui associe un flot de données. Sa syntaxe est : fopen("nom-de-fichier","mode")

Les modes d’ouverture. "r" ouverture d'un fichier texte en lecture "w" ouverture d'un fichier texte en écriture "a" ouverture d'un fichier texte en écriture à la fin "rb" ouverture d'un fichier binaire en lecture "wb" ouverture d'un fichier binaire en écriture "ab" ouverture d'un fichier binaire en écriture à la fin "r+" ouverture d'un fichier texte en lecture/écriture "w+" ouverture d'un fichier texte en lecture/écriture "a+" ouverture d'un fichier texte en lecture/écriture à la fin "r+b" ouverture d'un fichier binaire en lecture/écriture "w+b" ouverture d'un fichier binaire en lecture/écriture "a+b" ouverture d'un fichier binaire en lecture/écriture à la fin

Flots standards Trois flots standard peuvent être utilisés en C sans qu'il soit nécessaire de les ouvrir ou de les fermer : * stdin (standard input) : unité d'entrée (par défaut, le clavier). * stdout (standard output) : unité de sortie (par défaut, l'écran). * stderr (standard error) : unité d'affichage des messages d'erreur (par défaut, l'écran).

Fermeture du fichier La fonction fclose Elle permet de fermer le flot qui a été associé à un fichier par la fonction fopen. Sa syntaxe est: fclose(flot) où flot est le flot de type FILE* retourné par la fonction fopen correspondant. La fonction fclose retourne un entier qui vaut zéro si l'opération s'est déroulée normalement (et une valeur non nulle en cas d'erreur).

Entrée-Sortie formatée La fonction d'écriture fprintf La fonction fprintf, analogue à printf, permet d'écrire des données dans un fichier. Sa syntaxe est : fprintf(flot,"chaîne de contrôle",expression-1,..., expression-n) où flot est le flot de données retourné par la fonction fopen. Les spécifications de format utilisées pour la fonction fprintf sont les mêmes que pour printf.

Entrée-Sortie formatée La fonction de saisie fscanf La fonction fscanf, analogue à scanf, permet de lire des données dans un fichier. Sa syntaxe est semblable à celle de scanf : fscanf(flot,"chaîne de contrôle",argument-1,...,argument-n) où flot est le flot de données retourné par fopen. Les spécifications de format sont ici les mêmes que celles de la fonction scanf.

Impression-Lecture de caractères Les fonctions fgetc et fputc permettent respectivement de lire et d'écrire un caractère dans un fichier. La fonction fgetc, de type int, retourne le caractère lu dans le fichier. Elle retourne la constante EOF lorsqu'elle détecte la fin du fichier. Son prototype est : int fgetc(FILE* flot); où flot est le flot de type FILE* retourné par la fonction fopen. Comme pour la fonction getchar, il est conseillé de déclarer de type int la variable destinée à recevoir la valeur de retour de fgetc pour pouvoir détecter correctement la fin de fichier.

Impression-Lecture de caractères La fonction fputc écrit caractere dans le flot de données : int fputc(int caractere, FILE * flot ) Elle retourne l'entier correspondant au caractère lu (ou la constante EOF en cas d'erreur).

Impression-Lecture de caractères Il existe également deux versions optimisées des fonctions fgetc et fputc qui sont implémentées par des macros. Il s'agit respectivement de getc et putc. Leur syntaxe est similaire à celle de fgetc et fputc : int getc(FILE* flot ); int putc(int caractere, FILE * flot )

Relecture d’un caractère Il est possible de replacer un caractère dans un flot au moyen de la fonction ungetc : int ungetc(int caractere, FILE * flot ); Cette fonction place le caractère caractere (converti en unsigned char ) dans le flot flot. En particulier, si caractere est égal au dernier caractère lu dans le flot, elle annule le déplacement provoqué par la lecture précédente. Toutefois, ungetc peut être utilisée avec n'importe quel caractère (sauf EOF ).

Entrée-Sortie binaires Les fonctions d'entrées-sorties binaires permettent de transférer des données dans un fichier sans transcodage. Elles sont donc plus efficaces que les fonctions d'entrée-sortie standard, mais les fichiers produits ne sont pas portables puisque le codage des données dépend des machines. Elles sont notamment utiles pour manipuler des données de grande taille ou ayant un type composé. Leurs prototypes sont : size_t fread(void * pointeur, size_t taille, size_t nombre, FILE * flot ); size_t fwrite(void *pointeur, size_t taille, size_t nombre, FILE *flot); où pointeur est l'adresse du début des données à transférer, taille la taille des objets à transférer, nombre leur nombre. La fonction fread lit les données sur le flot flot et la fonction fwrite les écrit. Elles retournent toutes deux le nombre de données transférées.

Positionnement dans le fichier Il est également possible d'accéder à un fichier en mode direct, c'est-à-dire que l'on peut se positionner à n'importe quel endroit du fichier. La fonction fseek permet de se positionner à un endroit précis ; elle a pour prototype : int fseek(FILE * flot, long deplacement, int origine ); La variable deplacement détermine la nouvelle position dans le fichier. Il s'agit d'un déplacement relatif par rapport à l'origine ; il est compté en nombre d'octets. La variable origine peut prendre trois valeurs : *SEEK_SET (égale à 0) : début du fichier ; *SEEK_CUR (égale à 1) : position courante ; *SEEK_END (égale à 2) : fin du fichier.

Positionnement dans le fichier La fonction int rewind(FILE * flot ); permet de se positionner au début du fichier. Elle est équivalente à fseek( flot, 0, SEEK_SET); La fonction long ftell(FILE * flot ); retourne la position courante dans le fichier (en nombre d'octets depuis l'origine).

Des éléments fondamentaux en C++

La notion de flots Un flot: un canal sur lequel on peut écrire ou lire des données. Les opérateurs sont utilisés pour commander une lecture ou une écriture. Flots prédéfinis: * L'entrée standard (clavier par défaut) : cin * La sortie standard (terminal par défaut) : cout * Le canal des erreurs: cerr * Le canal clog :connecté au canal d'erreur et bufferisé (utilisé souvent pour la génération des comptes-rendus d'erreur).

La librairie de gestion de flots de données en C++

La librairie de gestion des fichiers en C++ Les fichiers en C++ sont traités comme des flux d’entrée (en cas de lecture) et sorties (en cas d’écriture). Classes de gestion de flux: fstream, ifstream, ofsetram, iostream, istream, ostream et ios. Les classes les plus spécifiques pour les fichiers sont : * ifstream : fichier d'entrée, sur lequel on peut lire des octets, * ofstream : fichier de sortie, sur lequel on peut écrire des octets. Ces classes sont définies dans le fichier fstream.h, à inclure avec le fichier iostream.h.

La librairie de gestion des fichiers en C++ ios istream ostream ifstream ofstream iostream fstream

La classe fstream ios istream ostream ifstream ofstream iostream fstream

La classe fstream: Les principales méthodes et propriétés fstream : Constructeur de la classe. ~fstream : Destructeur de la classe. open : Ouverture d’un fichier et de l’attacher à un buffer pour le transfert de l’information en lecture ou en écriture. close : Fermeture d’un fichier. setbuf : Attachement d’un un buffer au fichier, le type du buffer est filebuf. setmode : Assignation d’un mode au fichier (mode binaire ou texte). attach : Attachement d’un flots de donnée à travers le buffer au fichier. rdbuf : Récupération de l’objet filebuf attaché au fichier. fd : Retourne la description du fichier associé au flot de données (propriété). is_open : Teste si le flots de données (fichier) est ouvert ou non.

Le constructeur: Syntaxe fstream(); fstream( const char* szName, int nMode, int nProt = filebuf::openprot ); fstream( filedesc fd ); fstream( filedesc fd, char* pch, int nLength );

Le constructeur : Les paramètres szName: Le nom du fichier qui sera ouvert durant la construction. nMode: Un entier qui contient le mode d’ouverture du fichier. * ios::app La fonction permet d’ouvrir le fichier en mode append (en mode écriture à la fin du fichier). Les enregistrement à écrire sont écrits à la fin, même si on déplace la tête d’écriture par la fonction ostream::seekp au milieu du fichier. * ios::ate La fonction permet d’ouvrir le fichier en mode append (en mode écriture à la fin du fichier). Les enregistrement à écrire seront écrit à la position du pointeur de la tête d’écriture. * ios::in Le fichier sera ouvert en mode lecture. Le fichier doit exister. * ios::out Le fichier doit être ouvert en mode écriture. * ios::nocreate Si le fichier n’existe pas la fonction échoue. * ios::noreplace Si le fichier n’existe pas la fonction échoue. * ios::trunc Si le fichier existe il sera écrasé. * ios::binary Ouvre le fichier en mode binaire.

Le constructeur : Les paramètres nProt : Ce paramètre spécifie la spécification de protection du fichier. Ce paramètre peut prendre les valeurs suivantes : * filebuf::sh_compat Partage. * filebuf::sh_none Exclusif (pas de partage). * filebuf::sh_read Lecture partagée. * filebuf::sh_write Lecture partagée. fd : La description du fichier pch: Pointeur su un emplacement mémoire déjà réservé de taille nLength. NLength: La taille en octets de l’espace réservé pour la variable de lecture ou écriture.

La fonction d’ouverture: Syntaxe et paramètres Syntaxe void open( const char* szName, int nMode, int nProt = filebuf::openprot ); Ouvrire un fichier et l’attacher à un objet de la classe filebuf. Paramètres szName: Le nom du fichier à ouvrir. nMode: Un entier qui spécifie le mode d’ouverture. Les modes peuvent être combinés par le caractère OR ( | ). nProt: La protection du fichier.

La fonction de fermeture void close(); Permet de fermer le fichier déjà ouvert. Permet la déconnexion du fichier physique de son fichier logique.

La fonction setmode: Syntaxe et paramètres int setmode( int nMode = filebuf::text ); Permet d’affecter un mode au fichier (mode texte ou binaire). Elle est appelée après la méthode d’ouverture du fichier. La valeur de retour: La valeur de retour est soit le mode précédent soit –1 si les paramètres sont invalides ou si le mode ne peut pas être changé. nMode: Un entier qui doit être l’un de ces deux valeurs constantes: * filebuf::text Mode texte (ajout d’un caractère de fin de ligne à chaque fois que le caractère Retour-Chariot est écrit). * filebuf::binary Mode binaire.

La fonction is_open int is_open() const; Valeur de retour: Retourne une valeurs non nulle si le fichier est ouvert (attaché à un buffer : objet de type filebuf), sinon 0.

La classe ifstream ios istream ostream ifstream ofstream iostream fstream

La classe ifstream ifstream Constructeur de la classe. ~ifstream Destructeur de la classe open Ouvrir un fichier et l’associer à un objet buffer de type filebuf. close Fermer le fichier setbuf Associer le fichier à un buffer de type filebuf setmode Change le mode du fichier attach Attacher un objet buffer de type filebuf à un fichier déjà ouvert rdbuf Recevoir l’objet filebuf associé au fichier fd Retourne le descripteur du fichier is_open Teste si le fichier est ouvert ou non

Le constructeur ifstream(); ifstream( const char* szName, int nMode = ios::in, int nProt = filebuf::openprot ); ifstream( filedesc fd ); ifstream( filedesc fd, char* pch, int nLength );

La fonction d’ouverture void open( const char* szName, int nMode = ios::in, int nProt = filebuf::openprot ); La description des paramètre est présentée dans la classe précédentes. Le paramètre nMode est un mode lecture in.

La classe istream ios istream ostream ifstream ofstream iostream fstream

La classe istream istream Constructeur de la classe. ~istream Destructeur de la classe get C’est une fonction d’entrée. Elle permet d’extraire les données à partir du flot d’entrée (textuel). getline Elle permet d’extraire les caractères à partir du flot de données (textuels) read Permet d’extraire les données à partir du flot ignore Extraire les caractères invisibles peek Elle retourne un caractère sans l’extraire du flot de donnée gcount Retourne le nombre de caractères extraits durant la dernière opération seekg Changer le pointeur de lecture du flots de données tellg Recevoir la valeur du pointeur de lecture du flot de données operator >> Opérateur d’extraction pour différents type de données (non seulement textuelles)

Le constructeur istream( streambuf* psb ); istream( ); psb: Un pointeur sur le buffer de lecture

La fonction de lecture : read istream& read( char* pch, int nCount ); istream& read( unsigned char* puch, int nCount ); istream& read( signed char* psch, int nCount ); pch, puch, psch: Pointeur sur la chaîne de caractère dans laquelle on va lire nCount: Le nombre maximum de caractère à lire

La fonction seekg istream& seekg( streampos pos ); istream& seekg( streamoff off, ios::seek_dir dir ); pos: La nouvelle valeur de position du pointeur de lecture. off: La nouvelle valeur offset (à partir de laquelle on va se déplacer) dir: La direction de recherche. Cette valeur doit être l’une des valeurs suivantes : * ios::beg Recherche à partir du début du fichier. * ios::cur Recherche à partir de la position courante. * ios::end Recherche à partir de la fin.

La fonction tellg streampos tellg(); Retourne la valeur du pointeur de lecture.

La classe ofstream ios istream ostream ifstream ofstream iostream fstream

La classe ofstream ofstream Constructeur de la classe ~ofstream Destructeur de la classe open Ouverture du fichier et son attachement à un buffer d’écriture de type filebuf close Fermeture du fichier setbuf Associer le fichier à un buffer setmode Mettre le mode d’écriture du fichier (mode texte ou binaire) attach Attacher un buffer à un fichier déjà ouvert en écriture rdbuf Retourne le buffer associé à un fichier fd Retourne le descripteur du fichier ouvert en ecriture Returns the file descriptor associated with the stream. is_open Teste si le fichier est ouvert ou non

Le constructeur ofstream(); ofstream( const char* szName, int nMode = ios::out, int nProt = filebuf::openprot ); ofstream( filedesc fd ); ofstream( filedesc fd, char* pch, int nLength ); La majorité des paramètres sont expliqués dans la classe ofstream.

La fonction d’ouverture void open( const char* szName, int nMode = ios::out, int nProt = filebuf::openprot ); La majorité des paramètres sont décrits dans la classe ifstream. Le mode d’ouverture doit être out (mode en écriture). file is not found, the ios::failbit is set only if the ios::nocreate mode was used.

La classe ostream ios istream ostream ifstream ofstream iostream fstream

La classe ostream ostream Le constructeur de la classe ~ostream Le destructeur de la classe put Insère un caractère dans un flots de données (fichier) write Écrire une chaîne de caractères dans un fichier flush Vide le buffer correspondant au fichier ouvert en mode écriture seekp Change le pointeur d’écriture du fichier tellp Recevoir la valeur du pointeur d’écriture operator << Écrire des valeurs de différents type dans un flots de données ouvert en écriture endl Manipulateur (insérer le caractère Retour-Chariot) ends Manipulateur (insérer le caractère de fin de chaîne NULL)

Le constructeur ostream( streambuf* psb ); ostream( ); psb: Un pointeur sur un objet buffer d’écriture

La fonction de lecture : write ostream& write( const char* pch, int nCount ); ostream& write( const unsigned char* puch, int nCount ); ostream& write( const signed char* psch, int nCount ); pch, puch, psch: Un pointeur sur la chaîne ou le tableau de caractères nCount: Le nombre de caractère à écrire Cette fonction est souvent utilisée pour écrire dans des fichiers binaires.

La fonctionseekp ostream& seekp( streampos pos ); ostream& seekp( streamoff off, ios::seek_dir dir ); pos: La nouvelle valeur de position du pointeur d’écriture. off: La nouvelle valeur offset (à partir de laquelle on va se déplacer) dir: La direction de recherche. Cette valeur doit être l’une des valeurs suivantes : * ios::beg Écriture à partir du début du fichier. * ios::cur Écriture à partir de la position courante. * ios::end Écriture à partir de la fin.

La fonction tellp streampos tellp(); Retourne la position du pointeur d’écriture dans la fichier

La classe iostream ios istream ostream ifstream ofstream iostream fstream

La classe iostream iostream Le constructeur de la classe ~iostream Le destructeur de la classe

Exemple: Lecture d’un fichier séquentiel #include main() { ifstream fichierEntree("entree.dat"); // création d'un fichier "input" int val; // test si le fichier existe if(!fichierEntree) { cerr << "Erreur d'ouverture" << endl; return 1; // retour different de zero signifie "erreur" } // lecture d'une valeur dans le fichier fichierEntree >> val; cout << "Valeur lue: " << val << endl; return 0; } // resultats (le fichier entree.dat contient le texte "123"): Valeur lue: 123

Exemple: Lecture directe d’un fichier bineaire #include main() { ifstream fichierEntree("bin.dat"); int tableau[10]; if(!fichierEntree) { cerr << "Erreur d'ouverture" << endl; return 1; } fichierEntree.read((char *)tableau, sizeof(tableau)); cout << "Le tableau lu dans bin.dat est :\n"; for (int i=0; i <10; i++) cout << tableau[i] << " "; return 0; } // resultats: Le tableau lu dans bin.dat est :

Exemple: Ecriture d’un fichier séquentiel #include main() { // declaration (on ne connait pas encore le nom du fichier) ofstream fichierSortie; char MaChaine[20], nomFichier[20]; // obtenir le nom du fichier cout << "Entrez le nom du fichier: "; cin >> nomFichier; // on "ouvre" le fichier et on specifie son nom fichierSortie.open(nomFichier); // test si le fichier a bien ete "ouvert" // on peut egalement utiliser : if (!fichierSortie) if(fichierSortie.fail()) { cerr << "Erreur d'ouverture" << endl; return 1; } // obtenir du texte cout << "Entrez une chaine de caracteres : "; cin >> MaChaine; // ecrire le texte dans le nouveau fichier fichierSortie << "La chaine est: " << MaChaine << endl; return 0; } // resultats Entrez le nom du fichier : sortie.dat Entrez une chaine de caracteres : Bonjour // Le contenu du fichier sortie.dat sera : La chaine est : Bonjour

Exemple: Ecriture d’un fichier binaire #include main() { // on ne connait pas encore le nom du fichier ofstream fichierSortie; char nomFichier[20]; int tableau[10] = {1,2,3,4,5,6,7,8,9,10}; cout << "Entrez le nom du fichier: "; cin >> nomFichier; fichierSortie.open(nomFichier); if(fichierSortie.fail()) { cerr << "Erreur d'ouverture" << endl; return 1; } // l'ecriture est effectuee ici fichierSortie.write((char *)tableau, sizeof(tableau)); return 0; } // resultat Entrez le nom du fichier : bin.dat // le fichier bin.dat est cree et contient la variable // tableau

Utilsation des fichiers dans des fonctions (paramètres) #include // prototypes long TailleFichier(ifstream &); // la fonction recoit une variable "fichier input" void erreur(void); // fonction de message d'erreur main() { ofstream out("test.dat"); ifstream in; // sera ouvert plus tard int a[10] = {1,2,3,4,5,6,7,8,9,0}; long longueur; if(!out) erreur(); // ecriture du tableau a cout << "Création du fichier test.dat\n"; out.write((char *)a, sizeof(a)); out.close(); // fermeture du fichier in.open("test.dat"); if (!in) erreur(); longueur = TailleFichier(in); cout << "Le fichier test.dat a " << longueur << " octets\n"; return 0; } long TailleFichier(ifstream & fichier ) { long n=0; char c; while ( fichier.read(&c,sizeof(c)) ) n++; return n; }

Utilsation des fichiers dans des fonctions (paramètres) void erreur() { cerr << "Erreur d'ouverture de fichier\n"; exit(1); // terminaison du programme } // résultats Création du fichier test.dat Le fichier test.dat a 20 octets

La gestion de fichiers en Java.

La classe Java.io.FileInputStream Cette classe qui dérive de la classe InputStream permet d'ouvrir et d'accéder à un fichier en lecture, sous forme de flux de données. Constructeurs public FileInputStream (String path) throws SecurityException, FileNotFoundExceptionpublic FileInputStream (File file) throws SecurityException, FileNotFoundException Ils permettent de créer une instance de classe FileInputStream à partir du chemin d'accès à un fichier path ou d'une instance de classe File. public FileInputStream (FileDescriptor fdObj) throws SecurityException Construit une instance de classe FileInputStream à partir d'un descripteur de fichier fdObj.

La classe Java.io.FileInputStream M é thodes public int read () throws IOExceptionpublic int read (byte [ ] tab) throws IOException public int read (byte [ ] tab, int offset, int length) throws IOException, IndexOutOfBoundsExceptionpublic long skip (long n) throws IOExceptionpublic int available () throws IOExceptionpublic void close () throws IOException Méthodes de la classe InputStream outrepassées pour qu'elles s'appliquent à la lecture d'un fichier.

La classe Java.io.FileInputStream public final FileDescriptor getFD () throws IOException Permet d'obtenir un descripteur de fichier. protected void finalize () throws IOException Méthode de la classe Object outrepassée pour que le fichier ouvert à la création d'une instance de la classe FileInputStream soit fermé avant que le Garbage Collector n'intervienne pour détruire cet objet.

La classe Java.io.FileOutputStream Cette classe qui dérive de la classe OutputStream permet d'ouvrir un fichier et d'y écrire, sous forme de flux de données. Constructeurs public FileOutputStream (String path) throws SecurityException, FileNotFoundException public FileOutputStream (File file) throws SecurityException, FileNotFoundException Ils permettent de créer une instance de classe FileOutputStream à partir du chemin d'accès à un fichier path ou d'une instance de classe File. Si le fichier n'existe pas il est créé. public FileOutputStream (FileDescriptor fdObj) throws SecurityException Construit une instance de classe FileInputStream à partir d'un descripteur de fichier fdObj.

La classe Java.io.FileOutputStream M é thodes public void write (int b) throws IOExceptionpublic void write (byte [ ] tab) throws IOExceptionpublic void write (byte [ ] tab, int offset, int length) throws IOException, IndexOutOfBoundsExceptionpublic void close () throws IOException Méthodes de la classe OutputStream outrepassées pour qu'elles s'appliquent à l'écriture dans un fichier. public final FileDescriptor getFD () throws IOException Permet d'obtenir un descripteur de fichier.

La classe Java.io.FileOutputStream protected void finalize () throws IOException Méthode de la classe Object outrepassée pour que le fichier ouvert à la création d'une instance de la classe FileOutputStream soit fermé avant que le Garbage Collector n'intervienne pour détruire cet objet. Le moment où intervient le Garbage Collector n'étant généralement pas prévisible, il vaut mieux fermer soi-même le fichier avec la méthode close (), pour éviter d'en bloquer l'accès à d'autres programmes.

La classe Java.io.RandomAccessFile Cette classe qui implémente les interfaces DataInput et DataOuput, permet d'accéder aléatoirement à un fichier en mode lecture/écriture, ou uniquement en mode lecture. Constructeurs public RandomAccessFile (String path, String mode) throws SecurityException, IOException, IllegalArgumentExceptionpublic RandomAccessFile (File file, String mode) throws SecurityException, IOException, IllegalArgumentException

La classe Java.io.RandomAccessFile Ces constructeurs permettent d'ouvrir le fichier représenté par son chemin d'accès path ou par une instance de la classe File. Si mode est égal à "rw" (read/write) il est possible d'écrire ou de lire dans le fichier ouvert et le fichier est créé s'il n'existe pas. Si mode est égal à "r" (read), le fichier est accessible uniquement en lecture et par conséquent l'utilisation des méthodes d'écriture write...() de cette classe déclenchera une exception de classe IOException.

La classe Java.io.RandomAccessFile M é thodes public final FileDescriptor getFD () throws IOException Permet d'obtenir un descripteur de fichier. public long getFilePointer () throws IOException Renvoie la position courante dans le fichier. public void seek (long pos) throws IOException Déplace la position courante en pos dans le fichier. public long length () throws IOException Renvoie la taille courante du fichier.

La classe Java.io.RandomAccessFile public void close () throws IOException Ferme l'accès au fichier. public abstract int read () throws IOException Lit un octet dans le flux de données. Renvoie -1 si la fin est atteinte. public int read (byte [ ] tab) throws IOException Lit tab.length octets dans le tableau tab. Si la fin est atteinte pendant la lecture, tab est remplit avec les octets lus. Renvoie le nombre d'octets lus ou -1 si la fin est atteinte. public int read (byte [ ] tab, int offset, int length)throws IOException, IndexOutOfBoundsException Lit length octets dans le tableau tab, en le remplissant à partir de l'indice offset. Si la fin est atteinte pendant la lecture, tab est remplit avec les octets lus. Renvoie le nombre d'octets lus ou -1 si la fin est atteinte.

La classe Java.io.RandomAccessFile public int skipBytes (int n) throws IOException Méthode de l'interface DataInput implémentée pour qu'elle déplace de n octets la position courante dans le fichier. n peut être positif ou négatif (pour revenir en arrière). Renvoie n. public final void readFully (byte [ ] tab) throws IOExceptionpublic final void readFully (byte [ ] tab, int offset, int length) throws IOException, IndexOutOfBoundsException

La classe Java.io.RandomAccessFile public final boolean readBoolean () throws IOExceptionpublic final byte readByte () throws IOExceptionpublic final int readUnsignedByte () throws IOExceptionpublic final short readShort () throws IOExceptionpublic final int readUnsignedShort () throws IOExceptionpublic final char readChar () throws IOExceptionpublic final int readInt () throws IOExceptionpublic final long readLong () throws IOExceptionpublic final float readFloat () throws IOExceptionpublic final double readDouble () throws IOExceptionpublic final String readLine () throws IOExceptionpublic final String readUTF () throws IOException

La classe Java.io.RandomAccessFile public void write (int b) throws IOExceptionpublic void write (byte [ ] tab) throws IOExceptionpublic void write (byte [ ] tab, int offset, int length) throws IOException, IndexOutOfBoundsExceptionpublic final void writeBoolean (boolean v) throws IOExceptionpublic final void writeByte (int v) throws IOExceptionpublic final void writeShort (int v) throws IOExceptionpublic final void writeChar (int v) throws IOExceptionpublic final void writeInt (int v) throws IOExceptionpublic

La classe Java.io.RandomAccessFile final void writeLong (long v) throws IOExceptionpublic final void writeFloat (float v) throws IOExceptionpublic final void writeDouble (double v) throws IOExceptionpublic final void writeBytes (String s) throws IOExceptionpublic final void writeChars (String s) throws IOExceptionpublic final void writeUTF (String str) throws IOException