2 x byte zusammenkopieren

[Gast]

Abend,

wie kann ich 2 byte- Array am schnellsten zusammenkopieren?

byte[] b1;
byte[] b2;

muss ich da eine for- Schleife machen, oder geht das auch mit einer Zeile:

new byte[] {b1, b2}; geht leider nicht,

gute Nacht,

 

[Marco13]

Schnell? Schnell zu schreiben oder schnell auszuführen? :wink:

private static byte[] combine(byte a[], byte[] b)
{
    byte result[] = new byte[a.length+b.length];
    System.arraycopy(a,0,result,0,a.length);    
    System.arraycopy(b,0,result,a.length,b.length);
    return result;
}

 

[0x7F800000]

Schnell zu schreiben oder schnell auszuführen?

wieso stellst du diese "oder" Frage, dein code erfüllt doch beides?? oder wie soll's denn bitte noch schneller, oder noch kürzer gehen? ???:L

 

[Marco13]

Eine Alternative für "kürzer" wäre vielleicht noch

    private static byte[] combineBB(byte a[], byte[] b)
    {
        byte result[] = new byte[a.length+b.length];
        ((ByteBuffer)ByteBuffer.allocateDirect(a.length + b.length).put(a).put(b).rewind()).get(result);
        return result;
    }

Ein kurzer Test legt die Vermutung nahe, dass das (deutlich) langsamer ist, aber vermutlich hauptsächlich wegen der hin- und her-Umwandlung. Wenn man überall auf ByteBuffern arbeiten würde, wäre es evtl. schneller.

import java.nio.*;
import java.util.*;


class ByteBufferCopyTest
{
    public static void main(String aaahhhrgs[])
    {
        verify(5);

        for (int size=1000000; size<=10000000; size*=10)
        {
            test(size);
        }
    }

    private static byte[] create(int size)
    {
        byte b[] = new byte[size];
        for (int i=0; i<size; i++)
        {
            b[i] = (byte)('A'+(int)(Math.random() * 27));
        }
        return b;
    }

    private static void verify(int size)
    {
        byte a[] = create(size);
        byte b[] = create(size);
        byte c0[] = combineAC(a, b);
        byte c1[] = combineBB(a, b);
        System.out.println("a  = "+Arrays.toString(a));
        System.out.println("b  = "+Arrays.toString(b));
        System.out.println("c0 = "+Arrays.toString(c0));
        System.out.println("c1 = "+Arrays.toString(c1));
    }

    private static void test(int size)
    {
        byte a[] = create(size);
        byte b[] = create(size);

        for (int runs=10; runs<=50; runs+=10)
        {
            testAC(a,b,runs);
            testBB(a,b,runs);
        }
    }

    private static void testAC(byte a[], byte b[], int runs)
    {
        long before = System.currentTimeMillis();
        int result = 0;
        for (int i=0; i<runs; i++)
        {
            result += combineAC(a,b).length;
        }
        long after = System.currentTimeMillis();
        System.out.println(String.format("%10d",result)+" Time for "+runs+" runs on arrays of size "+a.length+" with AC is "+(after-before));
    }

    private static void testBB(byte a[], byte b[], int runs)
    {
        long before = System.currentTimeMillis();
        int result = 0;
        for (int i=0; i<runs; i++)
        {
            result += combineBB(a,b).length;
        }
        long after = System.currentTimeMillis();
        System.out.println(String.format("%10d",result)+" Time for "+runs+" runs on arrays of size "+a.length+" with BB is "+(after-before));
    }


    private static byte[] combineAC(byte a[], byte[] b)
    {
        byte result[] = new byte[a.length+b.length];
        System.arraycopy(a,0,result,0,a.length);
        System.arraycopy(b,0,result,a.length,b.length);
        return result;
    }

    private static byte[] combineBB(byte a[], byte[] b)
    {
        byte result[] = new byte[a.length+b.length];
        ((ByteBuffer)ByteBuffer.allocateDirect(a.length + b.length).put(a).put(b).rewind()).get(result);
        return result;
    }
}

 

[Marco13]

Hey - es geht NOCH kürzer, und genausoschnell (oder vielleicht einen winzigsten Hauch schneller) wie mit arrayCopy:

    private static byte[] combineBB(byte a[], byte[] b)
    {
        return ByteBuffer.allocate(a.length + b.length).put(a).put(b).array();
    }

 

[thE_29]

Ich hab noch eine Lösung!

  /**
   * 
   * @param buf1 byte[]
   * @param buf2 byte[]
   * @return byte[]
   */
  public static byte[] appendBytes(byte buf1[], byte buf2[])
  {
    ByteArrayOutputStream bOut = new ByteArrayOutputStream(buf1.length + buf2.length);
    bOut.write(buf1, 0, buf1.length);
    bOut.write(buf2, 0, buf2.length);
    return bOut.toByteArray();
  }

Ist aber die langsamste

Jedenfalls ist bei mir die System.arrayCopy meistens schneller (um 16-32ms) als die letzte Lösung von Maro13 und bei 46ms steht bei mir meine Lösung (wobei arrayCopy 0ms braucht).

Habe 2 Dateien mit 700KB verknüpfen lassen.

 

[Leroy42]

Jedenfalls ist bei mir die System.arrayCopy meistens schneller (um 16-32ms) als die letzte Lösung von Maro13 und bei 46ms steht bei mir meine Lösung (wobei arrayCopy 0ms braucht).

Habe 2 Dateien mit 700KB verknüpfen lassen.

Habt ihr sonst keine Probleme? :shock:

 

[0x7F800000]

nein. keine Probleme. stattdessen lauter Herausforderungen. :meld: