Copia profunda duplicada() de ByteBuffer de Java
nio deep-copy (5)
java.nio.ByteBuffer#duplicate()
devuelve un búfer de bytes nuevo que comparte el contenido del búfer anterior. Los cambios en el contenido del búfer anterior serán visibles en el nuevo búfer, y viceversa. ¿Qué pasa si quiero una copia profunda del búfer de bytes?
Basado en la solución de mingfai:
Esto le dará una copia profunda casi verdadera. Lo único perdido será la marca. Si orig es un HeapBuffer y el desplazamiento no es cero o la capacidad es menor que la matriz de respaldo, no se copian los datos externos.
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);
}
}
Como esta pregunta sigue surgiendo como uno de los primeros éxitos para copiar un ByteBuffer
, ofreceré mi solución. Esta solución no toca el búfer original, incluido el 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 cuida la posición, el límite o el orden para que se establezca igual que el original, eso es una adición fácil a lo anterior:
clone.position(original.position());
clone.limit(original.limit());
clone.order(original.order());
return clone;
Creo que la copia profunda no tiene por qué ser un byte[]
. Intenta 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;
}
Deberá iterar todo el búfer y copiar por valor en el nuevo búfer.
Una solución más 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;
}