Kopiowanie dwie tablice dwuwymiarową tablicę do innego dwuwymiarowego Java

Question

Mam jeszcze jedno pytanie Java :)

Przeczytałem this wątek, w którym wyjaśnia to wyraźnie, ale mam dwie tablice dwuwymiarową że chciałbym kopiować.

Rozumiem, że ten kawałek kodu

int[] array1and2 = new int[array1.length + array2.length]; 
System.arraycopy(array1, 0, array1and2, 0, array1.length); 
System.arraycopy(array2, 0, array1and2, array1.length, array2.length); 

Ale moje pytanie brzmi, jak mogę połączyć go z dwóch tablic gdzie

int a1[][] = new int [3][3]; 
int b1[][] = new int [3][3]; 
int c1[][] = new int [3][6]; 

gdzie c1 jest łączenie wspomnianych tablic?

Answer 1

użyciu rozwiązanie z task, że Ty już wspomniano w pytaniu. Przykład:

import java.util.Arrays; 

public class ArrayProgram { 

    public static void main(String[] args) { 
     int[][] array1 = { { 1, 2, 3 }, { 1, 2, 3 }, { 1, 2, 3 } }; 
     int[][] array2 = { { 4, 5, 6 }, { 7, 8, 9 }, { 0, 1, 2 } }; 
     int[][] result = ArrayCopier.joinSecondDimension(array1, array2); 
     for (int[] array : result) { 
      System.out.println(Arrays.toString(array)); 
     } 
    } 
} 

class ArrayCopier { 

    public static int[][] joinSecondDimension(int[][] array1, int[][] array2) { 
     int[][] array1and2 = new int[array1.length][]; 
     for (int index = 0; index < array1.length; index++) { 
      array1and2[index] = join(array1[index], array2[index]); 
     } 
     return array1and2; 
    } 

    public static int[] join(int[] array1, int[] array2) { 
     int[] array1and2 = new int[array1.length + array2.length]; 
     System.arraycopy(array1, 0, array1and2, 0, array1.length); 
     System.arraycopy(array2, 0, array1and2, array1.length, array2.length); 
     return array1and2; 
    } 
} 

reprodukcje:

[1, 2, 3, 4, 5, 6] 
[1, 2, 3, 7, 8, 9] 
[1, 2, 3, 0, 1, 2] 

EDIT
Wykonanie dowolną liczbę argumentów (Variable-Length Argument Lists):

import java.util.Arrays; 

public class ArrayProgram { 

    public static void main(String[] args) { 
     int[][] array1 = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; 
     int[][] array2 = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; 
     int[][] array3 = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; 
     test(array1); 
     test(array1, array2); 
     test(array1, array2, array3); 
    } 

    private static void test(int[][]... arrays) { 
     int[][] result = ArrayCopier.joinSecondDimension(arrays); 
     for (int[] array : result) { 
      System.out.println(Arrays.toString(array)); 
     } 
     System.out.println(); 
    } 
} 

class ArrayCopier { 

    public static int[][] joinSecondDimension(int[][]... arrays) { 
     int firstArrayLength = arrays[0].length; 
     int[][] result = new int[firstArrayLength][]; 
     for (int index = 0; index < firstArrayLength; index++) { 
      result[index] = join(getSecondDimArrays(index, arrays)); 
     } 
     return result; 
    } 

    public static int[] join(int[]... arrays) { 
     int[] result = new int[getTotalLength(arrays)]; 
     int destPos = 0; 
     for (int[] array : arrays) { 
      System.arraycopy(array, 0, result, destPos, array.length); 
      destPos += array.length; 
     } 
     return result; 
    } 

    private static int getTotalLength(int[]... arrays) { 
     int length = 0; 
     for (int[] array : arrays) { 
      length += array.length; 
     } 
     return length; 
    } 

    private static int[][] getSecondDimArrays(int index, int[][]... arrays) { 
     int[][] result = new int[arrays.length][]; 
     int resultIndex = 0; 
     for (int[][] array : arrays) { 
      result[resultIndex++] = array[index]; 
     } 
     return result; 
    } 
} 

reprodukcje:

[1, 2, 3] 
[4, 5, 6] 
[7, 8, 9] 

[1, 2, 3, 1, 2, 3] 
[4, 5, 6, 4, 5, 6] 
[7, 8, 9, 7, 8, 9] 

[1, 2, 3, 1, 2, 3, 1, 2, 3] 
[4, 5, 6, 4, 5, 6, 4, 5, 6] 
[7, 8, 9, 7, 8, 9, 7, 8, 9] 

Answer 2

Coś takiego powinno działać idealnie?

int a1[][] = new int [3][3]; 
int b1[][] = new int [3][3]; 
int c1[][] = new int [3][6]; 

for (int i = 0; i < a1.length; i++) { 
    System.arraycopy(a1[i], 0, c1[i], 0, a1[i].length); 
    System.arraycopy(a2[i], 0, c1[i], a1[i].length, a2[i].length); 
} 

A tak przy okazji, założyć od swoich wymiarów C wygląda następująco:

[ a, a, a, , , ] 
[ a, a, a, , b, ] 
[ a, a, a, , , ]