Java NIO - Tampon

Les tampons dans Java NIO peuvent être traités comme un objet simple qui agit comme un conteneur de taille fixe de blocs de données pouvant être utilisé pour écrire des données sur le canal ou lire des données à partir du canal afin que les tampons agissent comme des points de terminaison pour les canaux.

Il fournit un ensemble de méthodes qui facilitent la gestion des blocs de mémoire afin de lire et d'écrire des données vers et depuis les canaux.

Les tampons rendent le package NIO plus efficace et plus rapide par rapport aux E / S classiques, car les données d'E / S sont traitées sous la forme de flux qui ne prennent pas en charge les flux de données asynchrones et simultanés. .

Les paramètres primaires qui définissent le tampon Java NIO peuvent être définis comme suit:

  • Capacity - Quantité maximum de données / octet pouvant être stockées dans le tampon. La capacité d'un tampon ne peut pas être modifiée. Une fois que le tampon est plein, il doit être effacé avant d'y écrire.

  • Limit - Limit a une signification selon le mode de Buffer, c'est-à-dire en mode d'écriture de Buffer Limit est égal à la capacité, ce qui signifie que le maximum de données pouvant être écrites dans le tampon.Tandis qu'en mode de lecture du tampon Limit signifie la limite de la quantité de lire à partir du tampon.

  • Position - pointe vers l'emplacement actuel du curseur dans le buffer. Initialement réglé à 0 au moment de la création du buffer ou en d'autres termes c'est l'index de l'élément suivant à lire ou à écrire qui est mis à jour automatiquement par get () et put ( ) méthodes.

  • Mark - Marquer un signet de la position dans un tampon. Lorsque la méthode mark () est appelée, la position actuelle est enregistrée et lorsque reset () est appelé, la position marquée est restaurée.

Type de tampon

Les tampons Java NIO peuvent être classés dans les variantes suivantes en fonction des types de données traités par le tampon -

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

Méthodes importantes de Buffer

Comme déjà mentionné, Buffer agit comme un objet mémoire qui fournit un ensemble de méthodes qui rendent plus pratique la gestion des blocs de mémoire.Voici les méthodes importantes de Buffer -

  • allocate(int capacity) - Cette méthode est utilisée pour allouer un nouveau tampon avec une capacité comme paramètre. La méthode Allocate lève une exception IllegalArgumentException dans le cas où la capacité transmise est un entier négatif.

  • read() and put() - la méthode de lecture du canal est utilisée pour écrire des données du canal vers le tampon tandis que put est une méthode du tampon qui est utilisée pour écrire des données dans le tampon.

  • flip() - La méthode flip fait passer le mode de Buffer du mode d'écriture au mode de lecture. Elle remet également la position à 0 et définit la limite à l'endroit où se trouvait la position au moment de l'écriture.

  • write() and get() - la méthode d'écriture du canal est utilisée pour écrire des données du tampon au canal tandis que get est une méthode du tampon qui est utilisée pour lire les données du tampon.

  • rewind() - la méthode de rembobinage est utilisée lorsqu'une relecture est nécessaire car elle remet la position à zéro et ne modifie pas la valeur de limite.

  • clear() and compact() - clear et compact les deux méthodes sont utilisées pour faire du tampon du mode lecture au mode écriture.clear() met la position à zéro et la limite est égale à la capacité, dans cette méthode, les données dans le tampon ne sont pas effacées, seuls les marqueurs sont réinitialisés.

    D'autre part compact() La méthode est utilisée lorsqu'il reste des données non lues et que nous utilisons toujours le mode d'écriture du tampon dans ce cas, la méthode compacte copie toutes les données non lues au début du tampon et définit la position juste après le dernier élément non lu. mis à la capacité.

  • mark() and reset() - Comme son nom l'indique, la méthode de marquage est utilisée pour marquer une position particulière dans un tampon pendant la réinitialisation de la position de retour à la position marquée.

Exemple

L'exemple suivant montre l'implémentation des méthodes définies ci-dessus.

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());
   }
}

Production

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