Que sont mark et reset dans BufferedReader?

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

quand vous appelez mark() sur un BufferedReader il commencera à garder les données que vous lisez à partir de ce point vers l'avant dans son tampon interne. Lorsque vous appelez reset() il va revenir à la position marquée du flux, de sorte que le prochain read() s sera satisfait par le tampon en mémoire. Quand vous lisez au - delà de la fin de ce tampon, alors il sera parfaitement revenir à la lecture de nouvelles données. BufferedInputStream fonctionne de la même manière.

le paramètre int de mark lui indique le nombre maximum de caractères (pour BufferedReader ) ou d'octets (pour BufferedInputStream ) que vous voulez pouvoir revenir en arrière. Si vous lisez trop de données après la position marquée, alors la marque peut être "invalidée", et l'appel 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 enveloppé le StringReader dans un BufferedReader pour obtenir la méthode readLine() , mais StringReader s soutiennent déjà mark et reset sur leur propre! Les flux qui lisent à partir d'un en mémoire source de données prennent généralement en charge mark et reset eux-mêmes, parce qu'ils ont déjà toutes les données en mémoire, il est donc facile pour eux de le lire à nouveau. Les flux qui lisent à partir de fichiers ou de tuyaux ou de sockets réseau ne sont pas naturellement soutenez mark et reset , mais vous pouvez toujours ajouter cette fonctionnalité à n'importe quel flux en l'enveloppant dans un BufferedInputStream ou BufferedReader .

le mark() qui marque un point particulier d'un cours d'eau et le reset() remet le cours d'eau à 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 inspecter les données à venir.

de ce documentation:

le marque () marque de méthode une position dans l'entrée à laquelle le flux peut être" reset " par appel la méthode reset (). Le paramètre readLimit est le nombre de caractères qui peuvent être lus à partir du flux après avoir placé la marque avant la marque devient non valide. Par exemple, si mark () est appelé avec une lecture limite de 10, puis quand 11 caractères de données sont lus à partir du flux avant que la méthode reset() soit appelée, alors la marque est invalide et la l'instance de stream object n'est pas nécessaire pour se souvenir de la marque. Notez que le nombre de caractères qui peuvent être mémorisés par cette méthode peut être plus de la taille du tampon de lecture interne. Il n'est également pas dépendant du flux subordonné supportant la marque / réinitialisation fonctionnalité.

Reader::mark(int readLimit) la documentation dit:

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 . Appeler reset () 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

interface Lecteur ne pas vous permettent de retour, vous pouvez simplement lire. BufferedReader, d'un autre côté, crée un tampon, de sorte que vous êtes en mesure de retourner un peu en lisant. Et c'est ce que ces méthodes sont pour.

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

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

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.