迹忆客 专注技术分享

本文将帮助您了解 Java 虚拟机如何处理 ByteBuffer 类。 我们还将标明其范围并列出其主要参数。

最后，我们将运行两个 Java 程序来演示我们所讨论的内容。

Java中的ByteBuffer类

ByteBuffer 类用于包含一系列整数值。 这些整数值用于 I/O 操作。

它是一个有助于将字节从源传输到目的地的缓冲区。 此外，除了像缓冲区数组这样的存储之外，它还提供当前位置、限制、容量等抽象。

我们使用第一个示例来演示如何分配 ByteBuffer 并使用其对象。 在第二个示例中，我们将主要使用 getChar() 和 rewind() 方法。

请继续阅读以了解更多信息。

Java中ByteBuffer类的操作类别

1. 我们可以使用 get 和 put 方法（绝对和相对）来读取和写入单个字节。
2. 我们还可以使用（相对批量获取方法）将相邻的字节序列数据从该缓冲区传输到数组。
3. 我们还可以使用压缩、复制和切片字节缓冲区的方法（可选）。
4. 绝对和相对 get 和 put 方法，用于读取和写入其他基元类型的值，并将它们与特定字节顺序的字节序列相互转换。

ByteBuffer 类的层次结构：

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

字节缓冲区可以是直接的或间接的，也称为非直接的。 如果我们有一个直接字节缓冲区，Java 虚拟机 (JVM) 将会生成每个字节。

尝试直接对其执行本机 I/O 操作。 换句话说，JVM 试图避免在操作系统的本机 I/O 操作的每个指令之前（或之后）将缓冲区的内容复制到中间缓冲区（或从中间缓冲区复制）。

通过两种简单的方法，我们可以创建字节缓冲区：

1. allocate() - 我们可以为缓冲区的内容分配空间。

   以下代码块向您展示了如何创建一个具有 20 字节容量的空字节缓冲区。

   句法：

   ByteBuffer xyz = ByteBuffer.allocate(20);
   

2. wrap() - 将其包装到缓冲区的现有字节数组中。

   句法：

   // 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.
   

Java中字节缓冲区类的方法

该类可能包含更多方法。 但是，我们只会突出显示我们认为必要的内容。

其次，我们不会使用下表中的每种方法来实现。 我们的目标是让您熟悉一些最重要的方法及其用途。

如果您想阅读更多内容：Byte Buffer Class Oracle Docs。

Java中字节缓冲区的实现

以下程序不会向您展示表中给出的每种方法的示例。 但是，您将涵盖一些最常见的内容。

或者，您也可以参考官方文档。

例子：

1. 设定容量

   ByteBuffer bfr = ByteBuffer.allocate(20);
   

2. 获取字节缓冲区的容量。

   int capacity = bfr.capacity();
   

3. 使用绝对 put(int, byte) 设置位置。

   注意：该方法不影响位置。

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

4. 将位置设置为 10

   bfr.position(10);
   

5. 您还可以使用表中提到的相对 put(byte)。

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

6. 如果你想获得新职位

   int newposition = bfr.position(40);
   

7. 可以获取剩余字节数

   int remainingByteCount = bfr.remaining();
   

8. 设置限制

   bfr.limit(10);
   

实现：

我们将在这个程序中演示字节缓冲区类。 首先，我们将创建一个字节缓冲区及其对象并为其分配一个大小。

然后，我们将使用 PuntInt() 函数通过类型转换将 int 数据类型转换为 byte。

代码：

package bytebuffer.jiyik.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

输出:

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

Java中实现Byte Buffer类的getChar方法

我们将在此代码块中使用 string 而不是 int，就像之前的程序一样。 首先，我们声明字节缓冲区的容量为100。

然后，我们创建它的对象，用字符串代替 int 值，并为其分配大小。 之后，我们将使用 rewind() 来倒回该缓冲区，并在 while 循环中使用 getChar 函数。

请查看以下代码块以了解更多信息。

package bytebuffer.jiyik.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);

    }
}

输出:

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