Java NIO - Buffer

Os buffers em Java NIO podem ser tratados como um objeto simples que atua como um contêiner de tamanho fixo de blocos de dados que podem ser usados para gravar dados no canal ou ler dados do canal para que os buffers atuem como terminais para os canais.

Ele fornece um conjunto de métodos que tornam mais conveniente lidar com o bloco de memória para ler e gravar dados de e para os canais.

Os buffers tornam o pacote NIO mais eficiente e rápido em comparação com o IO clássico, pois no caso dos dados IO são negociados na forma de fluxos que não suportam fluxo de dados assíncrono e simultâneo. Também IO não permite a execução de dados em blocos ou grupos de bytes .

Os parâmetros primários que definem o buffer Java NIO podem ser definidos como -

Capacity - Quantidade máxima de dados / byte que pode ser armazenado no Buffer. A capacidade de um buffer não pode ser alterada. Uma vez que o buffer esteja cheio, ele deve ser limpo antes de gravar nele.
Limit - Limite tem significado de acordo com o modo de Buffer, ou seja, no modo de gravação de Buffer Limit é igual à capacidade, o que significa que o máximo de dados que podem ser gravados no buffer. Enquanto estiver no modo de leitura do buffer, Limite significa o limite de quantos dados podem ser ler do Buffer.
Position - Aponta para a localização atual do cursor no buffer. Inicialmente definido como 0 no momento da criação do buffer ou em outras palavras, é o índice do próximo elemento a ser lido ou escrito que é atualizado automaticamente por get () e put ( ) métodos.
Mark - Marque um marcador da posição em um buffer. Quando o método mark () é chamado, a posição atual é gravada e quando reset () é chamado, a posição marcada é restaurada.

Tipo de Buffer

Os buffers Java NIO podem ser classificados nas seguintes variantes com base nos tipos de dados com os quais o buffer lida -

ByteBuffer
MappedByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
ShortBuffer

Métodos importantes de buffer

Como já mencionado, o Buffer atua como um objeto de memória que fornece um conjunto de métodos que torna mais conveniente lidar com o bloco de memória. A seguir estão os métodos importantes de Buffer -

allocate(int capacity) - Este método é usado para alocar um novo buffer com capacidade como parâmetro. O método Allocate lança IllegalArgumentException no caso de a capacidade passada ser um número inteiro negativo.
read() and put() - o método read do canal é usado para gravar dados do canal para o buffer, enquanto put é um método do buffer que é usado para gravar dados no buffer.
flip() - O método flip muda o modo do Buffer do modo de gravação para o modo de leitura. Ele também define a posição de volta para 0 e define o limite de onde a posição estava no momento da gravação.
write() and get() - método de gravação de canal é usado para gravar dados de buffer em canal, enquanto get é um método de buffer que é usado para ler dados de buffer.
rewind() - o método de retrocesso é usado quando a releitura é necessária, pois define a posição de volta para zero e não altera o valor do limite.
clear() and compact() - clear e compact ambos os métodos são usados para fazer buffer do modo de leitura para gravação.clear() método torna a posição zero e o limite igual à capacidade, neste método os dados no buffer não são apagados, apenas os marcadores são reinicializados.

Por outro lado compact() método é usado quando restaram alguns dados não lidos e ainda usamos o modo de gravação do buffer neste caso o método compacto copia todos os dados não lidos para o início do buffer e define a posição imediatamente após o último elemento não lido. A propriedade limit ainda é definido para capacidade.
mark() and reset() - Como o nome sugere, o método de marca é usado para marcar qualquer posição particular em um buffer enquanto reinicia a posição de volta à posição marcada.

Exemplo

O exemplo a seguir mostra a implementação dos métodos definidos acima.

import java.nio.ByteBuffer;
import java.nio.CharBuffer;

public class BufferDemo {
   public static void main (String [] args) {
      //allocate a character type buffer.
      CharBuffer buffer = CharBuffer.allocate(10);
      String text = "bufferDemo";
      System.out.println("Input text: " + text);
      for (int i = 0; i < text.length(); i++) {
         char c = text.charAt(i);
         //put character in buffer.
		 buffer.put(c);
      }
      int buffPos = buffer.position();
      System.out.println("Position after data is written into buffer: " + buffPos);
      buffer.flip();
      System.out.println("Reading buffer contents:");
      while (buffer.hasRemaining()) {
         System.out.println(buffer.get());                   
      }
      //set the position of buffer to 5.
      buffer.position(5);
      //sets this buffer's mark at its position
      buffer.mark();
      //try to change the position
      buffer.position(6);
      //calling reset method to restore to the position we marked.
      //reset() raise InvalidMarkException if either the new position is less
      //than the position marked or merk has not been setted.
      buffer.reset();
      System.out.println("Restored buffer position : " + buffer.position());
   }
}

Resultado

Input text: bufferDemo
Position after data is written into buffer: 10
Reading buffer contents:
b
u
f
f
e
r
D
e
m
o
Restored buffer position : 5

↰ Previous page Next page ↱