Tous les tampons précités descendent de la classe abstraite Buffer qui propose l'essentiel des propriétés de ces objets.

• La capacité (capacity) représente le nombre d'éléments compris dans un objet Buffer.
• La limite (limit) fournit l'index du premier élément qui doit être lu ou écrit.
• La position est l'index du prochain élément à partir duquel une opération de lecture ou écriture pourra être effectuée.

Les différentes propriétés doivent obéir aux règles suivantes :

0 <= mark <= position <= limit <= capacity

Si la valeur de la position est plus grande que la limite du tampon ou si elle est négative, une exception IllegalArgumentException sera lancée. Le même événement se produira pour la limite, dans le second cas précité et si elle excéde la capacité du tampon.

A la création d'un nouvel objet Buffer, la position est égale à 0, la marque est indéfinie, tandis que la capacité et la limite dépendent du paramètrage d'allocation.

ByteBuffer tampon = ByteBuffer.allocate(1024);

Chacune de ces propriétés possèdent un accesseur ou/et un mutateur pour retourner ou fixer leur valeur.

int capacite = tampon.capacity();

int limite = tampon.limit();
Buffer tampon = tampon.limit(20);

int position = tampon.position();
Buffer tampon = tampon.position(5);

Buffer tampon = tampon.mark();

La méthode mark() fixe le repère de l'objet Buffer à la position spécifiée. Tant que la méthode mark() n'est pas invoquée, le repère n'est jamais défini. Toutefois, il est nécessaire que le repère soit défini avant tout appel de la méthode reset(). Dans le cas contraire, il sera lancé une exception InvalidMarkException.

Buffer tampon = tampon.mark();
//...
tampon = tampon.reset();

La méthode reset() réinitialise la position du tampon à la précédente position reprérée.

Plusieurs méthodes permettent de fixer les propriétés à des valeurs particulières, comme :

• fixer la limite à la capacité et la position à zéro (clear()).
• fixer la limite à la position courante et la position à zéro (flip()).
• fixe la position à zéro et ne modifie pas la limite (rewind()).

ByteBuffer tampon = ByteBuffer.allocate(1024);
tampon = tampon.clear();
int cap = tampon.capacity(); //cap = 1024
int pos = tampon.position(); pos = 0

tampon.position(512);
tampon = tampon.flip();
int lim = tampon.limit(); //lim = 512
int pos = tampon.position(); pos = 0

tampon = tampon.rewind();
int lim = tampon.limit(); //lim = 1024
int pos = tampon.position(); pos = 0

La récupération du nombre d'éléments entre la position courante et la limite s'effectue à partir de la méthode remaining(). Cette valeur indique la quantité d'octets ou autres qui peuvent être lus ou écrits avant d'atteindre la limite du tampon, soit celle spécifiée au moyen de la méthode limit(int nb), soit la capacité totale fournie lors de l'allocation de ce tampon. Une autre méthode, retournant une valeur booléenne, indique si des éléments sont compris (true) ou ne sont pas compris (false) entre la position courante et la limite.

int nb_restant = tampon.remaining();
if(tampon.hasRemaining()){
  //...
}

package nio;

import java.nio.ByteBuffer;

public class Tampon {
    public static void main(String args[]) throws Exception {
        ByteBuffer tampon = ByteBuffer.allocate(1024);
        for (int i = 0; i < 254; i++) {
            tampon.put((byte) i);
        }
        afficherCaracteristiques(tampon);
        System.out.println("APRES CREATION");
        afficherProprietes(tampon);
        tampon.flip();
        System.out.println("APRES FLIP()");
        afficherProprietes(tampon);
        if (tampon.hasArray()) {
            byte[] octets = tampon.array();
            System.out.println("Contenu du tableau d'octets du tampon : ");
            for (int i = 0; i < octets.length; i++) {
                System.out.print((char) octets[i]);
            }
            System.out.println("\nAPRES AFFICHAGE DU TABLEAU");
            afficherProprietes(tampon);
        }
        System.out.println("Contenu du tampon : ");
        while (tampon.hasRemaining())
            System.out.print((char) tampon.get());
        System.out.println("\nAPRES AFFICHAGE DU TAMPON");
        afficherProprietes(tampon);
        tampon.rewind();
        System.out.println("APRES REWIND()");
        afficherProprietes(tampon);
        tampon.clear();
        System.out.println("APRES CLEAR()");
        afficherProprietes(tampon);
    }

    public static void afficherProprietes(ByteBuffer buffer) {
        System.out.println("\tCapacité      : " + buffer.capacity());
        System.out.println("\tPosition      : " + buffer.position());
        System.out.println("\tLimite        : " + buffer.limit());
    }

    public static void afficherCaracteristiques(ByteBuffer buffer) {
        System.out.println("Direct        : " + buffer.isDirect());
        System.out.println("Lecture seule : " + buffer.isReadOnly());
    }
}