Detailed explanation of Java NIO buffering technology

A buffer is a piece of data that is about to be written to a channel or has just been read from a channel. It is an object that holds data and acts as an endpoint of a NIO channel. The buffer provides a formal mechanism for data access and the reading and writing process.

It is a major difference between NIO and the old Java I/O. Previously data was read and written directly from streams, now data can be read and written from buffers. In NIO, channel is a synonym for stream. To learn more about NIO channels, please read the previous tutorial Java NIO channels.

[[150477]]

NIO buffer characteristics

• The basic building block of Java NIO is the buffer.
• A buffer provides a fixed-size container for reading data.
• Every buffer is readable, but only certain buffers are writable.
• Buffers are the endpoints of channels.
• The contents of a read-only buffer are immutable, but its mark, position, and limit are mutable.
• By default, buffers are not thread-safe.

Buffer Type

Each primitive type has a corresponding buffer type. All buffer classes implement the Buffer interface. The most commonly used buffer type is ByteBuffer. The following are the buffer types provided in the Java NIO package.

• ByteBuffer
• CharBuffer
• ShortBuffer
• IntBuffer
• LongBuffer
• FloatBuffer
• DoubleBuffer
• MappedByteBuffer

Buffer capacity

The buffer has a fixed size. We can only store data less than the "fixed size". The fixed size value is called the buffer capacity. Once the buffer is full, it must be emptied before writing again. Once the capacity is set, it will not change during the life cycle of the buffer.

Buffer Limits

In write mode, the limit of the buffer is equal to the capacity. In read mode, the limit points to the bit after the last data bit in the buffer. When the buffer is written, the limit is incremented. The limit of the buffer is always greater than or equal to zero and less than or equal to the capacity, 0 <= limit <= capacity.

Buffer location

The position points to the current address of the buffer. When the buffer is created, the position is set to zero. During reading and writing, the position is incremented to the next index position. The position is always between zero and the limit.

Buffer Marking

Marking is similar to setting a bookmark to a buffer. When mark() is called, the current position is recorded, and when reset() is called, the marked position is restored.

Buffer flip, clear, and rewind

Buffer flip()

The flip() method is used to prepare the buffer for a get operation or to prepare a new write sequence. flip() sets the limit to the current position and then sets the position to 0.

Buffer clear()

The clear() method is used to prepare the buffer for a put operation or to prepare a new read sequence. clear() sets the limit to the capacity and sets the position to 0.

Buffer rewind()

The rewind() method is used to read the data that has been obtained again. rewind() sets the buffer position to 0.

How to read NIO buffer

1. First, create a buffer and allocate capacity. Buffer has an allocate(size) method that returns a Buffer object. ByteBuffer byteBuffer = ByteBuffer.allocate(512);
2. Perform flip operation and prepare for read operation. byteBuffer.flip();
3. Now we can read the data in. int numberOfBytes = fileChannel.read(byteBuffer);
4. Next, you can read data from the buffer. char c = (char)byteBuffer.get();

How to write to NIO buffer

1. Create a buffer and allocate capacity. ByteBuffer byteBuffer = ByteBuffer.allocate(512); //Capacity is set to 512
2. Write data. byteBuffer.put((byte) 0xff);

The above are two examples of read and write buffers. There are many types of buffers and many ways to read and write them. You can choose according to your usage requirements.

Original link: javapapers Translation: ImportNew.com - lemeilleur
Translation link: http://www.importnew.com/16721.html