two - join arrays java 8




Maneira fácil de concatenar matrizes de dois bytes (8)

Qual é o caminho mais fácil para concatenar matrizes de dois byte ?

Dizer,

byte a[];
byte b[];

Como faço para concatenar matrizes de dois byte e armazená-lo em outra matriz de byte ?


Mesclar dois arrays de bytes PDF

Se você estiver mesclando matrizes de dois bytes que contêm PDF, essa lógica não funcionará. Precisamos usar uma ferramenta de terceiros como o PDFbox do Apache:

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

A maneira mais elegante de fazer isso é com um ByteArrayOutputStream .

byte a[];
byte b[];

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

byte c[] = outputStream.toByteArray( );

Esta é a minha maneira de fazer isso!

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

Características :

  • Use varargs ( ... ) para ser chamado com qualquer número de bytes [].
  • Use System.arraycopy() que é implementado com código nativo específico da máquina, para garantir uma operação de alta velocidade.
  • Crie um novo byte [] com o tamanho exato necessário.
  • Aloque poucas variáveis ​​menos int reutilizando as variáveis i e len .
  • Comparação mais rápida com constantes.

Tenha em mente :

A melhor maneira de fazer isso é copiando o código @Jonathan . O problema vem das matrizes de variáveis ​​nativas, porque o Java cria novas variáveis ​​quando esse tipo de dado é passado para outra função.


Mais simples:

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

Outra possibilidade é 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();

Observe que a matriz deve ser dimensionada apropriadamente para começar, portanto, a linha de alocação é necessária (como array() simplesmente retorna a matriz de backing, sem considerar o deslocamento, posição ou limite).


Para dois ou vários arrays, este método utilitário simples e limpo pode ser usado:

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

Se você prefere ByteBuffer como @kalefranz, sempre há a possibilidade de concatenar dois byte[] (ou até mais) em uma linha, assim:

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

Você pode usar bibliotecas de terceiros para o Clean Code como o Apache Commons Lang e usá-lo como:

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




concatenation