Глубокая копия duplicate () Java ByteBuffer

Question

java.nio.ByteBuffer#duplicate() возвращает новый байтовый буфер, который разделяет содержимое старого буфера.Изменения в содержимом старого буфера будут видны в новом буфере, и наоборот.Что делать, если я хочу глубокую копию байтового буфера?

Answer 1

Я думаю, что глубокая копия не должна включать byte[].Попробуйте следующее:

public static ByteBuffer clone(ByteBuffer original) {
       ByteBuffer clone = ByteBuffer.allocate(original.capacity());
       original.rewind();//copy from the beginning
       clone.put(original);
       original.rewind();
       clone.flip();
       return clone;
}

Answer 2

Поскольку этот вопрос по-прежнему является одним из первых обращений к копированию ByteBuffer, я предложу свое решение.Это решение не касается исходного буфера, включая любой набор меток, и возвращает глубокую копию с той же емкостью, что и оригинал.

public static ByteBuffer cloneByteBuffer(final ByteBuffer original) {
    // Create clone with same capacity as original.
    final ByteBuffer clone = (original.isDirect()) ?
        ByteBuffer.allocateDirect(original.capacity()) :
        ByteBuffer.allocate(original.capacity());

    // Create a read-only copy of the original.
    // This allows reading from the original without modifying it.
    final ByteBuffer readOnlyCopy = original.asReadOnlyBuffer();

    // Flip and read from the original.
    readOnlyCopy.flip();
    clone.put(readOnlyCopy);

    return clone;
}

Если кто-то заботится о позиции, пределе или приказеустановить так же, как оригинал, тогда это простое дополнение к выше:

clone.position(original.position());
clone.limit(original.limit());
clone.order(original.order());
return clone;

Answer 3

Еще одно простое решение

public ByteBuffer deepCopy(ByteBuffer source, ByteBuffer target) {

    int sourceP = source.position();
    int sourceL = source.limit();

    if (null == target) {
        target = ByteBuffer.allocate(source.remaining());
    }
    target.put(source);
    target.flip();

    source.position(sourceP);
    source.limit(sourceL);
    return target;
}

Answer 4

Основано на решении mingfai:

Это даст вам почти истинную глубокую копию.Единственное, что потерял, будет знак.Если orig является HeapBuffer, а смещение не равно нулю или емкость меньше, чем базовый массив, то внешние данные не копируются.

public static ByteBuffer deepCopy( ByteBuffer orig )
{
    int pos = orig.position(), lim = orig.limit();
    try
    {
        orig.position(0).limit(orig.capacity()); // set range to entire buffer
        ByteBuffer toReturn = deepCopyVisible(orig); // deep copy range
        toReturn.position(pos).limit(lim); // set range to original
        return toReturn;
    }
    finally // do in finally in case something goes wrong we don't bork the orig
    {
        orig.position(pos).limit(lim); // restore original
    }
}

public static ByteBuffer deepCopyVisible( ByteBuffer orig )
{
    int pos = orig.position();
    try
    {
        ByteBuffer toReturn;
        // try to maintain implementation to keep performance
        if( orig.isDirect() )
            toReturn = ByteBuffer.allocateDirect(orig.remaining());
        else
            toReturn = ByteBuffer.allocate(orig.remaining());

        toReturn.put(orig);
        toReturn.order(orig.order());

        return (ByteBuffer) toReturn.position(0);
    }
    finally
    {
        orig.position(pos);
    }
}

Answer 5

Вам нужно будет перебрать весь буфер и скопировать по значению в новый буфер.