标签: bytebuffer

在Java中比较两个ByteBuffers的内容以检查相等性的最简单方法是什么？

我理解当分配一个directbytebuffer时,它不受垃圾收集的影响,但我想知道的是包装对象是否被垃圾收集.

例如,如果我分配了一个新的DirectByteBuffer dbb,然后使用dbb.duplicate()复制(浅层复制)它,我会在同一块内存中有两个包装器.

这些包装纸是否需要进行垃圾收集？如果我做了

while(true){
    DirectByteBuffer dbb2 = dbb.duplicate();
} 

我最终会自己OOM吗？

java.nio.ByteBuffer没有实现java.io.DataOutput或java.io.DataInput是否有一些微妙的原因,或者作者是不是选择这样做？映射调用似乎很简单(例如putInt() - > writeInt()).

我(以及其他一些人显然)的基本问题是较旧的类,它们知道如何使用通用接口序列化/序列化自己:DataInput/DataOutput.我想重用我的自定义序列化而无需为ByteBuffer编写自定义代理.

所以Java NIO架构师没有创建一个ByteBuffer接口,而是一个ByteBuffer类,它不是最终类,但它没有包 - 公共构造函数,因此它不能在其包之外进行子类化.阿福.:P

我有一个程序使用内存映射的文件字节缓冲区(通过FileChannel.map()获得)在一堆地方,我正在尝试追踪一个讨厌的错误,有问题的文件是打开的,因为有at至少一个ByteBuffer没有发布到垃圾收集.

我想创造一个InstrumentedByteBuffer看起来像一个字节的缓冲区类,但装饰定期ByteBuffer(或它的子类,例如MappedByteBuffer),并保持它的存在(包括创建新的缓冲区的赛道duplicate()和slice()) -这样我可以保持我的代码不变,使用ByteBuffer,我只需要修饰原始的字节缓冲区.

有没有办法做到这一点(通过反射或代理或其他)来绕过私人构造函数？我不需要将它发送到最终产品,我只需要暂时使用它来解决这个bug.

从非直接bytebuffer获取/放置比直接bytebuffer中的get/put快吗？

如果我必须从直接字节缓冲区读/写,最好先读取/写入线程本地字节数组,然后使用字节数组更新(写入)直接字节缓冲区吗？

变量声明:

byte[] eachPass = new byte[1600]; //used to store data from TargetDataLine for each pass
byte[] backingArray = new byte[16000]; //the complete data for one second
ByteBuffer buffer = ByteBuffer.wrap(backingArray); //buffer which stores the complete data
short[] audioSample = new short[16000/2]; //audio samples to be encoded
int passCounter = 0; /* After 10th pass, convert the byte[] to short[]
                      * using ByteBuffer */
int seconds = 0; // used …

这是我的问题.请跟我说一点解释:

我正在读取tiff图像到缓冲区; 我的tiff的每个像素由一个ushort(16位数据,非负数)表示.

我的图像大小是64*64 = 4096.当我的tiff加载到缓冲区时,缓冲区长度因此是8192(两倍于4096).我想这是因为在我的缓冲区中,计算机使用2个字节来存储单个像素值.

我想得到任何特定像素的值,在这种情况下,我应该将每2个字节组合为1个ushort吗？

例如:00000000 11111111 - > 0000000011111111？

这是我的代码:

public static void LoadTIFF(string fileName, int pxlIdx, ref int pxlValue)
        {
            using (Tiff image = Tiff.Open(fileName, "r"))
            {
                if (image == null)
                    return;

                FieldValue[] value = image.GetField(TiffTag.IMAGEWIDTH);
                int width = value[0].ToInt();

                byte[] buffer = new byte[image.StripSize()];
                for (int strip = 0; strip < image.NumberOfStrips(); strip++)
                    image.ReadEncodedStrip(strip, buffer, 0, -1);

                // do conversion here:
                //ushort bufferHex = BitConverter.ToUInt16(buffer, 0);            

                image.Close();

            }
        }

如何读取byte []缓冲区以确保我可以获得16位的ushort像素值？

谢谢

我遇到了这个问题:在Netty 4.0中创建一个关于从byte []到ByteBuf和ByteBuffer到ByteBuf的转换的ByteBuf.我很想知道转换的另一种方式:

io.netty.buffer.ByteBuf到java.nio.ByteBuffer

以及如何有效地进行,最小/无复制？我做了一些阅读,经过一些试验和错误,我找到了这种转换它的低效方式(有两个副本):

// io.netty.handler.codec.http.FullHttpRequest fullHttpRequest;
ByteBuf conByteBuf = fullHttpRequest.content ();                  
int numReadBytes = conByteBuf.readableBytes ();
conBytes = new byte[numReadBytes];
conByteBuf .readBytes (conBytes);                                // First Copy
ByteBuffer conByteBuffer = ByteBuffer.allocate (conBytes.length);
conByteBuffer.put (conByteBuf);                                  // Second Copy

我的问题是,我们可以避免一个或两个副本,并使ByteBuffer的内部缓冲区使用ByteBuf的内部缓冲区.

谢谢!

当我查看Java源代码时,我发现了一些不寻常的文件,这些文件大多与包中的ByteBuffers 有关,这些文件java.nio包含非常混乱的源代码并被标记This file was mechanically generated: Do not edit!.

这些文件还包含大部分空白行(有些甚至在javadocs中间(!!？)),可能是为了防止行号发生变化.我也看过一些java反编译器,例如procyon-decompiler,它们可以选择保留行号,但我怀疑是这种情况,因为在最终的奖励之前放空行不会改变.

以下是一些这些文件(我在网上找不到任何链接,并没有粘贴它们,因为我不想破坏任何版权,但你可以在src.zipJDK安装根目录下的文件夹中找到它们夹):

• java.nio.ByteBuffer中
• java.nio.DirectByteBufferR
• java.nio.Bits
• java.nio.BufferOverflowException

我很想知道:

• 哪个工具生成了这些文件？
• 为什么该工具保持行号相同？它是否使调试(堆栈跟踪)更容易？
• 为什么会使用工具来生成它们,而所有其他类都是由人类编程的？
• 为什么该工具会在括号内,最终荣誉之前,甚至在javadocs中随机放置空行？

我目前正在研究一些网络代码(这是我的第一个服务器)并且有一个关于优化特定函数的快速问题,该函数将值写为位然后将它们打包成一个字节.优化此功能的原因是因为每个服务器标记使用数千次来将数据打包发送到多个客户端.

示例可以更好地用于解释函数试图完成的内容:值3可以由两位表示.在二进制中,它看起来像00000011.该函数会将此二进制值转换为11000000.当再次调用该函数时,它将知道从第3个最高有效位(右边的第3个/第13个)开始,并在当前字节中最多写入6位.如果那时剩下的位要写,它将从一个新字节开始.

这样做的目的是节省空间,如果有多个值可以小于byte.

我目前的功能如下:

 private ByteBuffer out = ByteBuffer.allocate(1024);
 private int bitIndex = 0;
 /*
  * Value: The value to write
  * Amount: The number of bits to represent the value in.
  */
     public OutputBuffer writeBits(long value, int amount) {
    if (bitIndex != 0) {
        int remainingBits = 8 - bitIndex;
        int bytePos = out.position() - 1;
        byte current = out.get(bytePos);
        int shiftAmount = amount - remainingBits;
        int bitsWritten = amount < remainingBits ? amount : …