Manera fácil de concatenar matrices de dos bytes

4 minutos de lectura

avatar de usuario
androidGuy

¿Cuál es la manera fácil de concatenar dos byte arreglos?

Decir,

byte a[];
byte b[];

como concateno dos byte arreglos y almacenarlo en otro byte ¿formación?

  • Tenga en cuenta que Apache Commons, Guava de Google, System.arrayCopy, ByteBuffer y el – no tan eficiente pero legible – ByteArrayOutputStream todos han sido cubiertos. Tenemos más de 7 duplicados de las respuestas dadas aquí. Por favor, no publiques más engaños.

    -Maarten Bodewes

    18 de enero de 2019 a las 0:27


avatar de usuario
Kevin

La forma más elegante de hacerlo es con un ByteArrayOutputStream.

byte a[];
byte b[];

ByteArrayOutputStream outputStream = new ByteArrayOutputStream( );
outputStream.write( a );
outputStream.write( b );

byte c[] = outputStream.toByteArray( );

  • @vipw La razón por la que esto es elegante es porque si/cuando desea concatenar una tercera matriz más tarde, simplemente agrega la línea outputStream.write( c ); – no tiene que volver atrás y editar la línea donde crea la matriz de bytes de resultado. Además, reordenar las matrices es simple, a diferencia de usar el método arraycopy.

    –Wayne Uroda

    27 de agosto de 2012 a las 11:38


  • Además, esto es mucho más fácil cuando se trabaja con matrices de más de 2 bytes.

    – gardarh

    17 de abril de 2013 a las 10:16

  • Si está desperdiciando CPU y memoria depende de la frecuencia con la que realice la operación. Si es mil millones de veces por segundo, claro, optimícelo. De lo contrario, la legibilidad y la mantenibilidad podrían ser las consideraciones ganadoras.

    – vikingsteve

    6 de diciembre de 2013 a las 15:35

  • Si el consumo de memoria y/o el rendimiento son una preocupación, asegúrese de usar a.length + b.length como argumento para la ByteArrayOutputStream constructor. Tenga en cuenta que este método todavía copiará todos los bytes a una nueva matriz para asignar a c[]! Considera el ByteBuffer método un competidor cercano, que no desperdicia memoria.

    -Maarten Bodewes

    23 de junio de 2014 a las 13:11


  • Realmente no puedo darle un visto bueno a esto porque es solo un fragmento de código. No hay explicación de las piezas subyacentes aquí, que es la parte que me importa (y creo que la mayoría de la gente lo haría). Con mucho gusto le daría un visto bueno si hubiera una comparación de rendimiento entre System#arrayCopy(Object, int, Object, int, int) y ByteArrayOutputStream#put(byte[]), y detalló qué escenario es mejor para ambas opciones. Además, dicho esto, la respuesta también debería incluir arrayCopy ya que esa es otra solución.

    – motor de búsqueda27

    13 de julio de 2015 a las 19:19

Más directo:

byte[] c = new byte[a.length + b.length];
System.arraycopy(a, 0, c, 0, a.length);
System.arraycopy(b, 0, c, a.length, b.length);

  • funcionó como encanto

    – Shuhad zaman

    8 de marzo a las 10:35

avatar de usuario
Zoltan

Aquí hay una buena solución usando Guayaba‘s com.google.common.primitives.Bytes:

byte[] c = Bytes.concat(a, b);

Lo mejor de este método es que tiene una firma varargs:

public static byte[] concat(byte[]... arrays)

lo que significa que puede concatenar un número arbitrario de matrices en una sola llamada de método.

  • Esta es la forma más sencilla. Por cierto, no hay diferencia si estás usando Groovy.

    – lepe

    26 de octubre de 2020 a las 4:04

avatar de usuario
kalefranz

Otra posibilidad es usar java.nio.ByteBuffer.

Algo como

ByteBuffer bb = ByteBuffer.allocate(a.length + b.length + c.length);
bb.put(a);
bb.put(b);
bb.put(c);
byte[] result = bb.array();

// or using method chaining:

byte[] result = ByteBuffer
        .allocate(a.length + b.length + c.length)
        .put(a).put(b).put(c)
        .array();

Tenga en cuenta que la matriz debe tener el tamaño adecuado para comenzar, por lo que se requiere la línea de asignación (como array() simplemente devuelve la matriz de respaldo, sin tener en cuenta el desplazamiento, la posición o el límite).

avatar de usuario
Wayne Uroda

Otra forma es usar una función de utilidad (si lo desea, puede convertirlo en un método estático de una clase de utilidad genérica):

byte[] concat(byte[]...arrays)
{
    // Determine the length of the result array
    int totalLength = 0;
    for (int i = 0; i < arrays.length; i++)
    {
        totalLength += arrays[i].length;
    }

    // create the result array
    byte[] result = new byte[totalLength];

    // copy the source arrays into the result array
    int currentIndex = 0;
    for (int i = 0; i < arrays.length; i++)
    {
        System.arraycopy(arrays[i], 0, result, currentIndex, arrays[i].length);
        currentIndex += arrays[i].length;
    }

    return result;
}

Invocar así:

byte[] a;
byte[] b;
byte[] result = concat(a, b);

También funcionará para concatenar matrices de 3, 4, 5, etc.

Hacerlo de esta manera le brinda la ventaja de un código de copia de matriz rápido que también es muy fácil de leer y mantener.

avatar de usuario
Tomasz Przybylski

Puede usar bibliotecas de terceros para Clean Code como Apache Commons Lang y usarlo como:

byte[] bytes = ArrayUtils.addAll(a, b);

avatar de usuario
James.Xu

byte[] result = new byte[a.length + b.length];
// copy a to result
System.arraycopy(a, 0, result, 0, a.length);
// copy b to result
System.arraycopy(b, 0, result, a.length, b.length);

  • Misma respuesta que la aceptada y perdón, 5 minutos de retraso.

    -Maarten Bodewes

    17 de enero de 2019 a las 23:45

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad