Java uses the mark() function of the InputStream class to mark a position in the stream

Java uses the mark() function of the InputStream class to mark a position in the stream

The InputStream class is a core class in the Java IO library and is used to read byte stream data. It provides many methods to read byte data, one of the very useful methods is mark(). The mark() method can mark a position in the stream so that you can return to this position later to continue reading data.

The mark() method is defined as follows:

public synchronized void mark(int readLimit)

Among them, the readLimit parameter specifies that it can be read before calling the reset() method. The maximum number of bytes. That is, if the number of bytes read exceeds the value of readLimit, calling the reset() method will throw an IOException.

The following is a sample program that demonstrates how to use the mark() and reset() methods:

import java.io.*;

public class InputStreamMarkExample {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("data.txt");
            BufferedInputStream bis = new BufferedInputStream(fis);

            // 使用mark()方法在流中标记一个位置
            bis.mark(1024);

            // 读取前10个字节的数据
            byte[] buffer = new byte[10];
            bis.read(buffer);
            String data = new String(buffer);
            System.out.println("前10个字节的数据：" + data);

            // 调用reset()方法回到mark标记的位置
            bis.reset();

            // 读取10到20个字节的数据
            bis.skip(10);
            bis.read(buffer);
            data = new String(buffer);
            System.out.println("第10到20个字节的数据：" + data);

            // 关闭流
            bis.close();
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

In the above example, we first create a FileInputStream and decorate it with a BufferedInputStream, to improve efficiency. Then, we use the mark() method to mark a position in the stream, then read the first 10 bytes of data and print them out. Then, we call the reset() method to return to the position of the mark mark, then skip 10 bytes, read 10 to 20 bytes of data again, and print it out.

Through this example, we can see the usage of mark() and reset() methods. They help us when reading streaming data, save and return to a specific location so that we can re-read or process the data. However, it should be noted that before calling the reset() method, we must call the mark() method to set a mark position, and the set readLimit value must be large enough to ensure that the bytes read before calling the reset() method The number cannot exceed it. Otherwise, an IOException will be thrown.

In short, Java's InputStream class provides mark() and reset() methods, which can help us mark the position in the stream and return to this position to continue reading data when needed. This is very useful in certain scenarios, such as needing to re-read a certain piece of data or process some specific data blocks. We can make reasonable use of these methods according to actual needs to improve the flexibility and efficiency of the code.

The above is the detailed content of Java uses the mark() function of the InputStream class to mark a position in the stream. For more information, please follow other related articles on the PHP Chinese website!