Copia profunda duplicada() de ByteBuffer de Java

Question

java.nio.ByteBuffer#duplicate() devuelve un nuevo búfer de bytes que comparte el contenido del búfer antiguo. Los cambios en el contenido del viejo buffer serán visibles en el nuevo buffer, y viceversa. ¿Qué pasa si quiero una copia profunda del buffer de byte?

Answer 1

Tendrá que iterar todo el almacenamiento intermedio y copiar por valor en el nuevo almacenamiento intermedio.

Answer 2

Creo que la copia profunda no necesita involucrar a byte[]. Pruebe lo siguiente:

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 3

base fuera de la solución de mingfai:

Esto le dará una copia casi verdad profunda. Lo único perdido será la marca. Si orig es un HeapBuffer y el desplazamiento no es cero o la capacidad es inferior a la matriz de respaldo que los datos periféricos no se copian.

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 4

Como esta pregunta todavía aparece como uno de los primeros éxitos de la copia de un ByteBuffer, ofreceré mi solución. Esta solución no toca el búfer original, incluido ningún conjunto de marcas, y devolverá una copia profunda con la misma capacidad que el original.

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; 
} 

Si uno se preocupa por la posición, límite, o con el fin de ajustar el mismo que el original, entonces eso es una adición fácil de lo anterior:

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

Answer 5

Uno más solución simple

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; 
}