Простой способ объединения двух байтовых массивов
каков простой способ объединить два 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 создает новые переменные, когда этот тип данных передается другой функции.