web-dev-qa-db-fra.com

Que sont mark et reset dans BufferedReader?

J'aimerais savoir quelles sont les méthodes mark() et reset() de BufferedReader? Comment puis-je les utiliser? J'ai lu le Javadoc mais en tant que débutant, j'étais incapable de le comprendre.

javastreambufferedreader
21
saurabh ranu

Les méthodes de flux mark et reset fournissent un moyen de revenir en arrière dans le flux et de relire les données.

Lorsque vous appelez mark() sur une BufferedReader, les données lues à partir de ce moment seront conservées dans sa mémoire tampon interne. Lorsque vous appelez reset(), il retournera à la position marquée du flux, de sorte que la prochaine read()s sera satisfaite par le tampon en mémoire. Lorsque vous lisez au-delà de la fin de cette mémoire tampon, la lecture des nouvelles données s’effectue de manière transparente. BufferedInputStream fonctionne de la même manière.

Le paramètre int de mark lui indique le nombre maximal de caractères (pour BufferedReader) ou d'octets (pour BufferedInputStream) que vous souhaitez pouvoir inverser. Si vous lisez trop de données au-delà de la position marquée, la marque peut être "invalidée" et l'appel de reset() échouera avec une exception.

Un petit exemple:

BufferedReader r = new BufferedReader(new StringReader(
    "Happy Birthday to You!\n" +
    "Happy Birthday, dear " + System.getProperty("user.name") + "!"));
r.mark(1000); // save the data we are about to read
System.out.println(r.readLine()); // read the first line
r.reset(); // jump back to the marked position
r.mark(1000); // start saving the data again
System.out.println(r.readLine()); // read the first line again
System.out.println(r.readLine()); // read the second line
r.reset(); // jump back to the marked position
System.out.println(r.readLine()); // read the first line one final time

Dans cet exemple, j'ai encapsulé la StringReader dans une BufferedReader pour obtenir la méthode readLine(), mais StringReaders supporte déjà mark et reset par eux-mêmes! Les flux qui lisent à partir d'une source de données in-memory supportent généralement mark et reset eux-mêmes, car ils ont déjà toutes les données en mémoire, de sorte qu'il leur est facile de les relire. Les flux lus à partir de fichiers, de tubes ou de sockets réseau ne prennent naturellement pas en charge mark et reset, mais vous pouvez toujours ajouter cette fonctionnalité à n’importe quel flux en l’enveloppant dans un BufferedInputStream ou BufferedReader.

14
Boann

mark() marquant un point particulier dans un flux et reset() réinitialise le flux à la marque la plus récente. Ces méthodes fournissent une fonctionnalité book-marking qui vous permet de lire à l’avance dans le flux pour examiner les données à venir.

De cette documentation:

La méthode mark () marque une position dans l'entrée à laquelle le flux peut être "réinitialisé" avec appelant la méthode reset (). Le paramètre readLimit est le nombre de caractères pouvant être lus à partir du flux après avoir défini la marque avant la marque devient invalide. Par exemple, si mark () est appelé avec un read limite de 10, puis lorsque 11 caractères de données sont lus dans le flux avant que la méthode reset () soit appelée, la marque est invalide et le Il n'est pas nécessaire que l'instance d'objet de flux se souvienne de la marque. Notez que le nombre de caractères pouvant être mémorisés par cette méthode peut être supérieure à la taille du tampon de lecture interne. Ce n'est pas non plus dépend du flux subordonné supportant mark/reset fonctionnalité.

8
adatapost

Reader::mark(int readLimit) documentation dire:

Définit une position de marque dans ce lecteur. Le paramètre readLimit indique combien de caractères peuvent être lus avant que la marque ne soit invalidée . L'appel de réinitialisation () repositionnera le lecteur à la position marquée si readLimit n'a pas été dépassé.

Exemple:

import Java.io.*;
import static Java.lang.System.out;

public class App {

    public static final String TEST_STR = "Line 1\nLine 2\nLine 3\nLine 4\n";

    public static void main(String[] args) {

        try (BufferedReader in = new BufferedReader(new StringReader(TEST_STR))) {

            // first check if this Reader support mark operation
            if (in.markSupported()) {

                out.println(in.readLine());
                in.mark(0);                     // mark 'Line 2'
                out.println(in.readLine());
                out.println(in.readLine());
                in.reset();                     // reset 'Line 2'
                out.println(in.readLine());
                in.reset();                     // reset 'Line 2'
                out.println(in.readLine());
                in.mark(0);                     // mark 'Line 3'
                out.println(in.readLine());
                in.reset();                     // reset 'Line 3'
                out.println(in.readLine());
                out.println(in.readLine());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Sortie:

Line 1
Line 2
Line 3
Line 2
Line 2
Line 3
Line 3
Line 4
6
Anton Dozortsev

Imaginez que vous avez les caractères suivants dans le BufferReader = "123456789", si vous marquez à la position 4 par rapport au caractère '5' puis réinitialisez votre BufferReader, vous obtiendrez 12345.

1
Mikhaél Santos

L’interface de lecteur ne vous laisse pas revenir, vous pouvez simplement lire. BufferedReader, d’autre part, crée un tampon, ce qui vous permet de revenir un peu en lecture. Et voici à quoi servent ces méthodes.

Avec la méthode mark (), vous mettez un "marqueur" sur une position, vous pouvez ensuite continuer à lire. Une fois que vous réalisez que vous voulez renvoyer la position marquée, utilisez reset () pour cela. Et à partir de là, vous relisez les mêmes valeurs. Vous pouvez l'utiliser pour tout ce que vous voulez.

1
lzap

Voici un exemple.

int bufferSize = 4;
int readLimit = 4
ByteArrayInputStream byteInputStream = new ByteArrayInputStream("123456789abcdef".getBytes());
try(BufferedInputStream bufferedInputStream = new BufferedInputStream(byteInputStream, bufferSize)) {
        bufferedInputStream.mark(readLimit);
        System.out.print((char) bufferedInputStream.read());//byte1
        System.out.print((char) bufferedInputStream.read());//byte2
        System.out.print((char) bufferedInputStream.read());//byte3
        System.out.print((char) bufferedInputStream.read());//byte4
        bufferedInputStream.reset();
        System.out.print((char) bufferedInputStream.read());//byte5
        // Using this next reset() instead of the first one will throw an exception
        // bufferedInputStream.reset();

        System.out.print((char) bufferedInputStream.read());
        System.out.print((char) bufferedInputStream.read());
        System.out.print((char) bufferedInputStream.read());
    }

Sortie: 12341234

Dans le but de readLimit, voici une belle référence.

0
Orvyl