Array in kleinere Teile teilen

Question

Ich möchte ein großes Byte-Array in kleinere Stücke teilen (sagen wir 64 Bytes). Bitte hilf mir dabei.

Answer 1

können Sie die Methode Arrays.copyOfRange verwenden (Original, von, bis)

public static byte[][] divideArray(byte[] source, int chunksize) { 


     byte[][] ret = new byte[(int)Math.ceil(source.length/(double)chunksize)][chunksize]; 

     int start = 0; 

     for(int i = 0; i < ret.length; i++) { 
      ret[i] = Arrays.copyOfRange(source,start, start + chunksize); 
      start += chunksize ; 
     } 

     return ret; 
    } 

Oder Sie können verwenden, wie Max das System.arraycopy

public static byte[][] divideArray(byte[] source, int chunksize) { 


     byte[][] ret = new byte[(int)Math.ceil(source.length/(double)chunksize)][chunksize]; 

     int start = 0; 

     for(int i = 0; i < ret.length; i++) { 
      if(start + chunksize > source.length) { 
       System.arraycopy(source, start, ret[i], 0, source.length - start); 
      } else { 
       System.arraycopy(source, start, ret[i], 0, chunksize); 
      } 
      start += chunksize ; 
     } 


     return ret; 
    } 

Answer 2

vorgeschlagen Siehe Arrays.copyOfRange um Hilfe. Sie können dies in einer Schleife verwenden, um Ihr Array in mehrere kleinere Blöcke aufzuteilen.

Answer 3

Nun, System.arraycopy (src, fromPos, dest, toPos, Länge) wird im Allgemeinen als schneller als Arrays.copyOfRange betrachtet.

byte[] source = ...read it from somewhere...; 
byte[] newArray = new byte[64]; 
System.arraycopy(source, 0, newArray, 0, 64); 

Answer 4

Sie haben zwei Möglichkeiten:

• System.arraycopy(...)
• Array.copyOfRange(...)

sie beide die gleiche Art und Weise arbeiten, aber während erste einzige Kopie verwaltet wird zweite gemeint sein verwendet, um den neuen Chunk zur gleichen Zeit zuzuweisen.

Ich bewertete sie mit einem Ergebnis, das System.arraycopy schneller ist, wenn Sie Chunks alle zusammen vor dem Aufteilen Ihres Arrays, aber etwas langsamer zuweisen, wenn Sie sie beim Kopieren zuweisen: in diesem Fall sollten Sie Array.copyOfRange verwenden.

Answer 5

Dies tun ...

byte[] source = new byte[2048]; 
    byte[] target = new byte[1024]; 

// fill source with some data... 

    Array.Copy(source, buffer, 1024); 

Answer 6

Damian erste Methode des Vash (die mit Arrays.copyOfRange()) Nullen an das Ende des letzten Brocken hinzufügt, wenn der Eingang nicht genau ein Vielfaches von chunksize ist .

Sie könnten dies wollen stattdessen verwenden:

public static List<byte[]> divideArray(byte[] source, int chunksize) { 

    List<byte[]> result = new ArrayList<byte[]>(); 
    int start = 0; 
    while (start < source.length) { 
     int end = Math.min(source.length, start + chunksize); 
     result.add(Arrays.copyOfRange(source, start, end)); 
     start += chunksize; 
    } 

    return result; 
} 

und falls es ist sinnvoll, die gleiche Sache mit Arraylist suchen:

public static List<List<String>> divideList(List<String> source, int chunksize) { 
    List<List<String>> result = new ArrayList<List<String>>(); 
    int start = 0; 
    while (start < source.size()) { 
     int end = Math.min(source.size(), start + chunksize); 
     result.add(source.subList(start, end)); 
     start += chunksize; 
    } 
    return result; 
    } 

Answer 7

Wenn Sie schauen, um etwas Speicher sparen, eine leichte Modifikation Damian Vashs Antwort würde helfen (in diesem Fall wird jedem verbleibenden Block auch keine vollständige 64-Byte-Blockgröße zugewiesen ...)

private byte[][] splitChunks(byte[] source) 
{ 
    byte[][] ret = new byte[(int)Math.ceil(source.length/(double)CHUNK_SIZE)][]; 
    int start = 0; 
    for(int i = 0; i < ret.length; i++) { 
     if(start + CHUNK_SIZE > source.length) { 
      ret[i] = new byte[source.length-start]; 
      System.arraycopy(source, start, ret[i], 0, source.length - start); 
     } 
     else { 
      ret[i] = new byte[CHUNK_SIZE]; 
      System.arraycopy(source, start, ret[i], 0, CHUNK_SIZE); 
     } 
     start += CHUNK_SIZE ; 
    } 
    return ret; 
}