Łatwy sposób na połączenie dwóch bajtów

Jak łatwo połączyć dwie bytetablice?

Mówić,

byte a[];
byte b[];

Jak połączyć dwie bytetablice i przechowywać je w innej bytetablicy?

Najprostszy:

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

Najbardziej eleganckim sposobem na to jest użycie ByteArrayOutputStream.

byte a[];
byte b[];

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

byte c[] = outputStream.toByteArray( );

Oto rozwiązanie ładny użyciu Guava „s com.google.common.primitives.Bytes:

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

Wspaniałą rzeczą w tej metodzie jest to, że ma podpis varargs:

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

co oznacza, że ​​możesz połączyć dowolną liczbę tablic w jednym wywołaniu metody.

Inną możliwością jest użycie java.nio.ByteBuffer.

Coś jak

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

Zauważ, że tablica musi być odpowiednio dobrana na początek, więc wymagana jest linia alokacji (ponieważ array()po prostu zwraca tablicę bazową, bez uwzględnienia przesunięcia, położenia lub ograniczenia).

Innym sposobem jest użycie funkcji narzędzia (jeśli chcesz, możesz to uczynić statyczną metodą ogólnej klasy narzędzi):

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

Wywołaj tak:

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

Będzie również działał dla łączenia 3, 4, 5 tablic itp.

Robiąc to w ten sposób, zyskujesz przewagę szybkiego kodu arraycopy, który jest również bardzo łatwy do odczytania i utrzymania.

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

Jeśli wolisz ByteBuffer@kalefranz, zawsze istnieje możliwość połączenia dwóch byte[](lub nawet więcej) w jednym wierszu, tak jak to:

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

Możesz używać bibliotek stron trzecich do czyszczenia kodu, takich jak Apache Commons Lang i używać go w następujący sposób:

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

W przypadku dwóch lub wielu tablic można zastosować tę prostą i czystą metodę narzędzia:

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

Scal dwie tablice bajtów PDF

Jeśli scalasz dwie tablice bajtów zawierające PDF, ta logika nie będzie działać. Musimy użyć narzędzia innej firmy, takiego jak PDFbox firmy Apache:

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

Jeśli nie chcesz zadzierać z rozmiarami tablic, po prostu użyj magii łączenia łańcuchów:

byte[] c = (new String(a, "l1") + new String(b, "l1")).getBytes("l1");

Lub zdefiniuj gdzieś w swoim kodzie

// concatenation charset
static final java.nio.charset.Charset cch = java.nio.charset.StandardCharsets.ISO_8859_1;

I użyć

byte[] c = (new String(a, cch) + new String(b, cch)).getBytes(cch);

To oczywiście działa również z więcej niż dwoma łączeniami łańcuchowymi za pomocą +operatora dodawania.

Oba "l1"i ISO_8859_1wskazują zestaw znaków Western Latin 1, który koduje każdy znak jako pojedynczy bajt. Ponieważ nie są wykonywane tłumaczenia wielobajtowe, znaki w ciągu będą miały takie same wartości jak bajty (z tym wyjątkiem, że zawsze będą interpretowane jako wartości dodatnie, ponieważ nie charsą podpisane). Przynajmniej w przypadku środowiska wykonawczego dostarczonego przez Oracle każdy bajt zostanie zatem poprawnie „zdekodowany”, a następnie „ponownie zakodowany”.

Uwaga: ciągi znacznie rozszerzają tablicę bajtów, co wymaga dodatkowej pamięci. Łańcuchy mogą być również internowane i dlatego nie będą łatwe do usunięcia. Ciągi są również niezmienne, więc wartości wewnątrz nich nie można zniszczyć. Dlatego nie powinieneś łączyć wrażliwych tablic w ten sposób, ani nie powinieneś używać tej metody dla tablic o większych bajtach. Wymagane byłoby również wyraźne wskazanie tego, co robisz, ponieważ ta metoda konkatenacji macierzy nie jest powszechnym rozwiązaniem.

To jest mój sposób, aby to zrobić!

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

Funkcje :

• Użyj varargs ( ...), aby wywołać dowolną liczbę bajtów [].
• Użyj, System.arraycopy()które jest zaimplementowane z natywnym kodem specyficznym dla maszyny, aby zapewnić szybkie działanie.
• Utwórz nowy bajt [] z dokładnym wymaganym rozmiarem.
• Przydziel niewiele mniej intzmiennych, ponownie wykorzystując zmienne ii len.
• Szybsze porównanie ze stałymi.

Pamiętaj :

Lepszym sposobem na to jest skopiowanie kodu @Jonathan . Problem pochodzi z rodzimych tablic zmiennych, ponieważ Java tworzy nowe zmienne, gdy ten typ danych jest przekazywany do innej funkcji.