Demonstration der Byte-Pufferklasse in Java

1. ByteBuffer-Klasse in Java
2. Operative Kategorien der Klasse ByteBuffer in Java
3. Methoden der Byte-Pufferklasse in Java
4. Implementierung von Byte Buffer in Java
5. Implementieren Sie die getChar-Methode der Byte Buffer Class in Java

Dieser Artikel hilft Ihnen zu verstehen, wie eine Java Virtual Machine mit einer ByteBuffer-Klasse umgeht. Wir werden auch seinen Umfang bezeichnen und seine wichtigsten Parameter auflisten.

Abschließend werden wir zwei Java-Programme ausführen, um zu demonstrieren, was wir besprochen haben.

ByteBuffer-Klasse in Java

Eine ByteBuffer-Klasse wird verwendet, um eine Reihe von Integer-Werten zu enthalten. Diese ganzzahligen Werte werden in den E/A-Operationen verwendet.

Es ist ein Puffer, der hilft, Bytes von einer Quelle zu einem Ziel zu übertragen. Außerdem bietet es neben der Speicherung wie einem Pufferarray Abstraktionen wie aktuelle Position, Grenze, Kapazität usw.

Wir verwenden das erste Beispiel, um zu demonstrieren, wie man einen ByteBuffer allokiert und seine Objekte verwendet. Im zweiten Beispiel verwenden wir hauptsächlich die Methoden getChar() und rewind().

Bitte lesen Sie weiter, um mehr zu erfahren.

Operative Kategorien der Klasse ByteBuffer in Java

1. Wir können die Methoden get und put (absolut und relativ) verwenden, um einzelne Bytes zu lesen und zu schreiben.
2. Wir können auch (relative bulk get-Methoden) verwenden, um angrenzende Sequenzdaten von Bytes aus diesem Puffer in ein Array zu übertragen.
3. Wir können auch Methoden zum Komprimieren, Duplizieren und Slicen eines Bytepuffers verwenden (optional).
4. Absolute und relative get- und put-Methoden zum Lesen und Schreiben von Werten anderer primitiver Typen, deren Umwandlung in und aus Byte-Folgen in einer bestimmten Byte-Reihenfolge.

Hierarchie der Klasse ByteBuffer:

java.lang.Object> java.nio.Buffer>java.nio.ByteBuffer`

Ein Byte-Puffer kann direkt oder indirekt sein, was auch als nicht-direkt bezeichnet wird. Die Java Virtual Machine (JVM) macht alles, wenn wir einen direkten Bytepuffer haben.

Versuchen Sie, native E/A-Vorgänge direkt darauf auszuführen. Mit anderen Worten, JVM versucht zu vermeiden, dass der Inhalt des Puffers vor (oder nach) jeder Beschwörung einer nativen E/A-Operation des Betriebssystems in (oder aus) einem Zwischenpuffer kopiert wird.

Mit zwei einfachen Methoden können wir Bytepuffer erstellen:

1. allocate() - Wir können Speicherplatz für den Inhalt des Puffers zuweisen.

   Der folgende Codeblock zeigt Ihnen, wie Sie einen leeren Byte-Puffer mit einer Kapazität von 20 Byte erstellen.

   Syntax:

   ByteBuffer xyz = ByteBuffer.allocate(20);
   

2. wrap() - wickelt es in ein bestehendes Byte-Array eines Puffers ein.

   Syntax:

   // Initilize an int array
   int[] xyz = {5, 10, 15};
   IntBuffer intBuffer = IntBuffer.wrap(xyz);
   // Note:intButter makes a view of this byte buffer as an int buffer.
   

Methoden der Byte-Pufferklasse in Java

Es gibt weitere Methoden, die diese Klasse enthalten kann. Wir werden jedoch nur diejenigen hervorheben, die wir für notwendig halten.

Zweitens werden wir nicht jede Methode in der folgenden Tabelle für unsere Implementierung verwenden. Wir wollen Sie mit einigen der wichtigsten Methoden und deren Anwendung vertraut machen.

Wenn Sie mehr lesen möchten: Byte Buffer Class Oracle Docs.

Implementierung von Byte Buffer in Java

Das folgende Programm zeigt Ihnen nicht für jede in der Tabelle angegebene Methode ein Beispiel. Aber Sie werden einige der häufigsten behandeln.

Alternativ können Sie auch auf die offizielle Dokumentation verweisen.

Beispiele:

1. Kapazität einstellen

   ByteBuffer bfr = ByteBuffer.allocate(20);
   

2. Holen Sie sich die Kapazität des Byte-Puffers.

   int capacity = bfr.capacity();
   

3. Stellen Sie die Position mit absolutem put(int, byte) ein.

   Hinweis: Diese Methode hat keinen Einfluss auf die Position.

   // position=2
   bfr.put(2, (byte) 2xFF);
   

4. Stellen Sie die Position auf 10 ein

   bfr.position(10);
   

5. Sie können auch das in der Tabelle erwähnte relative put(byte) verwenden.

   bfr.put((byte) 2xFF); // position 2
   

6. Wenn Sie die neue Position bekommen möchten

   int newposition = bfr.position(40);
   

7. Sie können die verbleibende Byteanzahl abrufen

   int remainingByteCount = bfr.remaining();
   

8. Einstellen des Limits

   bfr.limit(10);
   

Implementierung:

In diesem Programm demonstrieren wir die Bytepufferklasse. Zuerst erstellen wir einen Bytepuffer und sein Objekt und weisen ihm eine Größe zu.

Dann konvertieren wir den Datentyp int durch Typumwandlung mit der Funktion PuntInt() in das Byte.

Code:

package bytebuffer.delftstack.com.util;
/*We will demonstrate the byte buffer class in this program.
 *First of all, we will create a byte buffer and its object and allocate it a size.
 *Then, we will convert the int data type to the byte by typecasting with the help of PuntInt()
 *function */
import java.nio.*;
import java.util.*;
// main class
public class Example1 {
  // main function
  public static void main(String[] args) {
    // capacity declaration
    int allocCapac = 6;
    // Creating the ByteBuffer
    try {
      // creating object of ByteBuffer
      // and allocating size capacity
      ByteBuffer createOBJ = ByteBuffer.allocate(allocCapac);
      // putting the int to byte typecast value
      // in ByteBuffer using putInt() method
      createOBJ.put((byte) 20);
      createOBJ.put((byte) 40);
      createOBJ.put((byte) 60);
      createOBJ.put((byte) 80);
      createOBJ.put((byte) 100);
      createOBJ.put((byte) 120);
      createOBJ.rewind();
      // We will print the byter buffer now
      System.out.println("The byte buffer: " + Arrays.toString(createOBJ.array()));
    }
    // catch exception for error
    catch (IllegalArgumentException e) {
      System.out.println("IllegalArgumentException catched");
    } catch (ReadOnlyBufferException e) {
      System.out.println("ReadOnlyBufferException catched");
    }
  }
}
// class

Ausgang:

The byte buffer: [20, 40, 60, 80, 100, 120]

Implementieren Sie die getChar-Methode der Byte Buffer Class in Java

Wir werden in diesem Codeblock wie im vorherigen Programm string anstelle von int verwenden. Zunächst deklarieren wir die Kapazität des Bytebuffers mit 100.

Dann erstellen wir sein Objekt, setzen den String anstelle des int-Werts und weisen ihm eine Größe zu. Danach werden wir diesen Puffer mit rewind() zurückspulen und in der while-Schleife schließlich die Funktion getChar anwenden.

Bitte sehen Sie sich den folgenden Codeblock an, um mehr zu erfahren.

package bytebuffer.delftstack.com.util;

/*In this code block, we will use string instead of int like the previous program.
First of all, we declare the capacity of the byte buffer to `100`.
Then, we create its object, put the string instead of the int value, and allocate it with size.
After that, we will use `rewind()` to rewind this buffer and in the while loop and finally apply the
getChar function. Please check out the following code block to learn more:*/

import java.nio.ByteBuffer;
public class Example2 {
  public static void main(String[] args) {
    // Declaring the capacity of the ByteBuffer
    int capacity = 100;
    // Creating the ByteBuffer
    // creating object of ByteBuffer
    // and allocating size capacity
    ByteBuffer bufferOBJ = ByteBuffer.allocate(capacity);
    // putting the string in the bytebuffer
    bufferOBJ.asCharBuffer().put("JAVA");
    // rewind the Bytebuffer
    bufferOBJ.rewind(); // The position is set to zero and the mark isdiscarded.
    // Declaring the variable
    char charr;
    // print the ByteBuffer
    System.out.println("This is the default byte buffer: ");
    while ((charr = bufferOBJ.getChar()) != 0) System.out.print(charr + "");
    // rewind the Bytebuffer
    bufferOBJ.rewind();
    // Reads the char at this buffer's current position
    // using getChar() method
    char FrstVal = bufferOBJ.getChar();
    // print the char FrstVal
    System.out.println("\n\n The first byte value is : " + FrstVal);
    // Reads the char at this buffer's next position
    // using getChar() method
    char NXTval = bufferOBJ.getChar();
    // print the char FrstVal
    System.out.print("The next byte value is : " + NXTval);
  }
}

Ausgang:

This is the default byte buffer:
JAVA
The first byte value is : J
The next byte value is : A