concatenar caracteres en java

Una forma fácil de concatenar matrices de dos bytes

Question

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

Decir,

byte a[];
byte b[];

¿Cómo concatenar dos matrices de byte y almacenarlas en otra matriz de byte ?

Answer 1

Combinar dos matrices de bytes PDF

Si está fusionando matrices de dos bytes que contienen PDF, esta lógica no funcionará. Necesitamos usar una herramienta de terceros como PDFbox de Apache:

ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
mergePdf.addSource(new ByteArrayInputStream(a));
mergePdf.addSource(new ByteArrayInputStream(b));
mergePdf.setDestinationStream(byteArrayOutputStream);
mergePdf.mergeDocuments();
c = byteArrayOutputStream.toByteArray();

Answer 2

¡Esta es mi manera de hacerlo!

public static byte[] concatByteArrays(byte[]... inputs) {
    int i, len = 0;
    for (i = 0; i < inputs.length; i++) {
        len += inputs[i].length;
    }
    byte[] r = new byte[len];
    i = len = 0;
    for (i = 0; i < inputs.length; i++) {
        System.arraycopy(inputs[i], 0, r, len, inputs[i].length);
        len += inputs[i].length;
    }
    return r;
}

Caracteristicas :

• Utilice varargs ( ... ) para llamar con cualquier número de byte [].
• Use System.arraycopy() que se implementa con un código nativo específico de la máquina, para garantizar una operación de alta velocidad.
• Cree un nuevo byte [] con el tamaño exacto que lo necesita.
• Asigne un poco menos de variables int reutilizando las variables i y len .

Ten en cuenta :

La mejor manera de hacerlo es copiar el código @Jonathan . El problema proviene de las matrices de variables nativas, porque Java crea nuevas variables cuando este tipo de datos se pasa a otra función.

Answer 3

Aquí hay una buena solución que usa com.google.common.primitives.Bytes Guava :

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

Lo bueno de este método es que su firma es

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

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

Answer 4

Dos llamadas a System.arraycopy son magras y malas, pero no fáciles de entender (es más difícil de entender como revisor de código).

Un enfoque más legible usando java.nio.ByteBuffer :

byte[] ab = ByteBuffer.wrap(new byte[a.length + b.length]).put(a).put(b).array();

Answer 5

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

byte a[];
byte b[];

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

byte c[] = outputStream.toByteArray( );

Answer 6

Más sencillo:

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

Answer 7

Otra forma es usar una función de utilidad (si lo desea, podría hacer de esto 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;
}

Invocan así:

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

También funcionará para concatenar 3, 4, 5 matrices, 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.

Answer 8

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();

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).

Answer 9

Para dos o múltiples arreglos, este método de utilidad simple y limpio se puede utilizar:

/**
 * Append the given byte arrays to one big array
 *
 * @param arrays The arrays to append
 * @return The complete array containing the appended data
 */
public static final byte[] append(final byte[]... arrays) {
    final ByteArrayOutputStream out = new ByteArrayOutputStream();
    if (arrays != null) {
        for (final byte[] array : arrays) {
            if (array != null) {
                out.write(array, 0, array.length);
            }
        }
    }
    return out.toByteArray();
}

Answer 10

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

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

Answer 11

Si prefiere ByteBuffer como @kalefranz, siempre existe la posibilidad de concatenar dos byte[] (o incluso más) en una línea, como esta:

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

Answer 12

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