Java

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Fichiers à accès aléatoire en Java

Pour de nombreuses applications, l'accès séquentiel est inefficace. Ces applications, appelées applications en temps réel, nécessitent l'accès immédiat à un enregistrement pendant qu'un client est en attente.

Un programme dans lequel l'utilisateur effectue des requêtes directes est un programme interactif. Par exemple, si un client appelle un grand magasin avec une question sur une facture mensuelle, le représentant du service clientèle ne veut pas accéder à chaque compte client de manière séquentielle.

Supposons que la base de données du magasin contienne des dizaines de milliers d’enregistrements de compte à lire et que l’enregistrement client en question se trouve à la fin de la liste. Il faudrait trop de temps pour accéder à l’enregistrement du client si tous les enregistrements devaient être lus de manière séquentielle.

Les représentants du service clientèle ont plutôt besoin de fichiers à accès aléatoire, c'est-à-dire des fichiers dans lesquels les enregistrements peuvent être récupérés directement dans n'importe quel ordre. Les fichiers aléatoires sont également appelés fichiers à accès direct ou fichiers à accès instantané.

Vous pouvez utiliser la classe FileChannel de Java pour créer vos propres fichiers à accès aléatoire. Un objet FileChannel(fichier du canal) est un moyen de lire et d’écrire un fichier. Un FileChannel peut être recherché, ce qui signifie que vous pouvez rechercher un emplacement de fichier spécifique et que les opérations peuvent commencer à n’importe quel emplacement spécifié.

Le tableau suivant décrit certaines méthodes la classe FileChannel.

MéthodeDescription
FileChannel open(Path file, OpenOption... options)Ouvre ou crée un fichier et renvoie un canal de fichier pour accéder au fichier.
long position()Renvoie la position du fichier du canal
FileChannel position(long newPosition)Définit la position du fichier du canal
int read(ByteBuffer buffer)Lit une séquence d'octets du canal dans la mémoire tampon (buffer)
long size()Renvoie la taille du fichier du canal
int write(ByteBuffer buffer)Écrit une séquence d'octets sur le canal à partir du tampon

Plusieurs méthodes du tableau ci-dessus utilisent un objet ByteBuffer. Comme son nom l'indique, un ByteBuffer est simplement un emplacement de stockage pour les octets en attente de lecture ou d'écriture. Un tableau d'octets peut être encapsulé ou englobé dans un ByteBuffer à l'aide de la méthode wrap() de la classe ByteBuffer.

Le fait d'encapsuler un tableau d'octets dans une mémoire tampon entraîne que les modifications apportées à la mémoire tampon affectent aussi le tableau, ainsi que les modifications apportées au tableau affectent la mémoire tampon.

La création d'un FileChannel utilisable pour l'écriture aléatoire de données nécessite la création d'un ByteBuffer et plusieurs autres étapes.

  •   Vous pouvez utiliser la méthode newByteChannel() de la classe Files pour obtenir un ByteChannel pour un chemin. La méthode newByteChannel() accepte les arguments Path et StandardOpenOption qui spécifient le mode d’ouverture du fichier.
  •  Le ByteChannel renvoyé par la méthode newByteChannel() peut ensuite être converti en FileChannelà l'aide d'une instruction similaire à celle-ci.
                                            FileChannel fc = (FileChannel)Files.newByteChannel(file, READ, WRITE);
                                        
  •  Vous pouvez créer un tableau d'octets. Par exemple, un tableau d'octets peut être construit à partir d'une chaîne en utilisant la méthode getBytes()comme suit :
                                            String s = "Hello, world";
                                            byte[] donnees = s.getBytes();
                                        
  •  Le tableau d'octets peut être encapsulé dans un ByteBuffercomme suit:
                                            ByteBuffer out = ByteBuffer.wrap(data);
                                        
  •  Ensuite, le ByteBuffer rempli peut être écrit dans le FileChanneldéclaré avec une instruction telle que la suivante:
                                            fc.write(out);
                                        
  •   Vous pouvez vérifier si le contenu d'un ByteBuffer a été utilisé à l’aide de la méthode hasRemaining()
  •   Après avoir écrit le contenu d'un ByteBuffer, vous pouvez réécrire le même contenu en utilisant la méthode rewind() pour repositionner le ByteBuffer au début du tampon.
Exemple :
                                    import java.nio.ByteBuffer;
                                    import java.nio.channels.FileChannel;
                                    import java.nio.file.*;
                                    import static java.nio.file.StandardOpenOption.*;
                                    
                                    public class Test {
                                        public static void main(String args[]) {
                                            Path chemin = Paths.get("intro.txt");
                                            String s = "Hello";
                                            byte[] data = s.getBytes();
                                            ByteBuffer out = ByteBuffer.wrap(data);
                                            FileChannel fc = null;
                                            try {
                                                fc = (FileChannel) Files.newByteChannel(chemin, READ, WRITE);
                                                fc.position(0);
                                                while (out.hasRemaining())
                                                    fc.write(out);
                                    
                                                out.rewind();
                                                fc.position(22);
                                    
                                                while (out.hasRemaining())
                                                    fc.write(out);
                                    
                                                fc.close();
                                            } catch (Exception e) {
                                                System.out.println("Erreur : " + e);
                                            }
                                        }
                                    }
                            

le contenu du fichier avant d'exécuter le programme

                                Learning a new programming language is an easy thing
                            

le contenu du fichier après l'exécution du programme

                                Helloing a new programHellolanguage is an easy thing
                            

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :