Простой способ объединения двух байтовых массивов

каков простой способ объединить два byte массивы?

сказать,

byte a[];
byte b[];

как объединить два byte массивы и хранить его в другом byte массив?

12 ответов


самый простой:

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

самый элегантный способ сделать это с помощью ByteArrayOutputStream.

byte a[];
byte b[];

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

byte c[] = outputStream.toByteArray( );

вот хорошее решение с помощью гуавы ' s com.google.common.primitives.Bytes:

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

самое замечательное в этом методе заключается в том, что его подпись

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

- это означает, что вы можете объединить произвольное количество массивов в одном вызове метода.


другая возможность-использование java.nio.ByteBuffer.

что-то вроде

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

обратите внимание, что массив должен быть соответствующим размером для начала, поэтому требуется строка распределения (как array() просто возвращает резервный массив, не принимая во внимание смещение, положение или ограничение).


другой способ-использовать функцию утилиты (вы можете сделать это статическим методом универсального класса утилиты, если хотите):

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

Invoke следующим образом:

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

Он также будет работать для объединения 3, 4, 5 массивы и т. д.

это дает вам преимущество быстрого кода arraycopy, который также очень легко читать и поддерживать.


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

два System.arraycopy вызовы являются тощими и средними, но нелегкими на глазах (сложнее понять, как рецензент кода, то есть).

более читаемый подход с использованием java.nio.ByteBuffer:

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

Если вы предпочитаете ByteBuffer как @kalefranz, всегда есть возможность объединить два byte[] (или даже больше) в одной строке, например:

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

вы можете использовать сторонние библиотеки для чистого кода, такого как Apache Commons Lang, и использовать его как:

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

для двух или нескольких массивов можно использовать этот простой и чистый метод утилиты:

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

объединить два массива байтов PDF

Если вы объединяете два байтовых массива, которые содержат PDF, эта логика не будет работать. Нам нужно использовать сторонний инструмент, такой как PDFbox от Apache:

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

это мой способ сделать это!

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

особенности:

  • использовать varargs (...) вызывается с любым количеством байтов [].
  • использовать System.arraycopy() то снабжено с кодом машины специфическим родным, для обеспечения высокоскоростной деятельности.
  • создайте новый байт[] с точным размером, который ему нужен.
  • выделить чуть меньше int переменные, повторно используя i и len переменная.

имейте в виду:

лучший способ сделать это-скопировать @Jonathan code. Проблема возникает из собственных массивов переменных, поскольку Java создает новые переменные, когда этот тип данных передается другой функции.