Moyen facile de concaténer des tableaux de deux octets

La façon La plus élégante de le faire est avec un ByteArrayOutputStream.

byte a[];
byte b[];

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

byte c[] = outputStream.toByteArray( );

, Voici une belle solution à l'aide de Goyave's com.google.common.primitives.Bytes:

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

La grande chose à propos de cette méthode est que sa signature est

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

, ce qui signifie que vous pouvez concaténer un nombre arbitraire de tableaux dans un seul appel de méthode.

Une autre possibilité est d'utiliser java.nio.ByteBuffer.

Quelque Chose comme

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

Notez que le tableau doit être correctement dimensionné pour commencer, donc la ligne d'allocation est requise (car array() renvoie simplement le tableau de sauvegarde, sans tenir compte du décalage, de la position ou de la limite).

Une autre façon est d'utiliser une fonction utilitaire (vous pouvez en faire une méthode statique d'une classe utilitaire générique si vous le souhaitez):

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

Invoquer comme ceci:

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

Cela fonctionnera également pour concaténer des tableaux 3, 4, 5, etc.

Le faire de cette façon vous donne l'avantage du code arraycopy rapide qui est également très facile à lire et à maintenir.

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

Deux appels System.arraycopy sont maigres et moyens, mais pas faciles à comprendre (plus difficile à comprendre en tant que réviseur de code, c'est-à-dire).

Une approche plus lisible en utilisant java.nio.ByteBuffer:

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

Si vous préférez ByteBuffer comme @kalefranz, il y a toujours la possibilité de concaténer deux byte[] (ou même plus) dans une ligne, comme ceci:

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

Vous pouvez utiliser des bibliothèques tierces pour du Code propre comme Apache Commons Lang et l'utiliser comme:

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

Pour deux ou plusieurs tableaux, cette méthode utilitaire simple et propre peut être utilisée:

/**
 * 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();
}

Fusionner deux tableaux D'octets PDF

Si vous fusionnez deux tableaux d'octets contenant du PDF, cette logique ne fonctionnera pas. Nous devons utiliser un outil tiers comme PDFbox d'Apache:

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

C'est ma façon de le faire!

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

Caractéristiques:

• utilisez varargs (...) pour être appelé avec n'importe quel nombre d'octets[].
• Utilisez System.arraycopy() qui est implémenté avec du code natif spécifique à la machine, pour assurer un fonctionnement à grande vitesse.
• créez un nouvel octet [] avec la taille exacte qui en a besoin.
• allouez un peu moins de variables int en réutilisant les variables i et len.

Gardez à l'esprit:

La meilleure façon de faire ceci, est en copiant le code @Jonathan . Le problème provient des tableaux de variables natives, car Java crée de nouvelles variables lorsque ce type de données est passé à une autre fonction.