Skalierung eines Arrays (Matrix)

Question

Das Ziel dieses Programms ist es, ein größeres Byte-Array zu erstellen, das um den Faktor 10 vom Originalarray skaliert ist. Zum Beispiel sollte die 1 in [0][0] ein 10x10 Quadrat von 1 in dem neuen Array sein. Ich liefere den Code und die Ausgabe, die während der Population des größeren Arrays ordnungsgemäß zu funktionieren scheint, aber dann unterschiedliche Werte ausdruckt. Ich experimentiere gerade mit den Reihen, um die Anzahl der Variablen, mit denen ich während des Tests arbeite, zu begrenzen. Kann jemand einen Grund dafür nennen?

public class Test 
{
static byte[][] byteArray =
{{1, 0},
 {0, 1}};

public static void main(String[] args)
{
    byte newarray[][] = converter();
    for(int i = 0; i < 20; i++)
    {
        System.out.println(newarray[i][0]);
    }
}

private static byte[][] converter()
{
    byte[][] b = new byte[20][20];

    for(int r = 0; r < 2; r++)
    {
        for(int i = 0; i < 10; i++)
        {
            b[r+i][0] = byteArray[r][0];
            System.out.println(byteArray[r][0]);
            System.out.println(b[r+i][0]);
        }
    }

    return b;
}

}

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Answer 1

Warum nicht einfach die abgeschnittene Integer-Division zu Ihrem Vorteil nutzen:

static void printMat(byte[][] mat) 
// nur eine Hilfsfunktion zum Drucken einer Matrix
{ 
    for(byte[] row : mat)
    {
        System.out.println(Arrays.toString(row));
    }
}

private static byte[][] stretch(byte[][] bytes, int rfactor, int cfactor)
// strecke die Matrix in 'bytes'
// strecke die Zeilen um 'rfactor' und die Spalten um 'cfactor'
{ 
    // Erstelle eine leere Matrix:
    int rows = bytes.length*rfactor; // Zeilen in der neuen Matrix
    int cols = bytes[0].length*cfactor; // Spalten in der neuen Matrix
    byte[][] out = new byte[rows][cols]; // unsere neue, gestreckte Matrix

    // Gehe durch die Zeilen und Spalten der *neuen* Matrix:
    for(int r = 0; r < rows; r++)
    {
        for(int c = 0; c < cols; c++)
        {
            // Teile die Zeilen- und Spaltenindizes durch die entsprechenden Faktoren, um den korrekten Wert in der Originalmatrix zu finden.
            // Bei der ganzzahligen Division wird einfach etwaiger Rest abgeworfen, was wir wollen.
            out[r][c] = bytes[r/rfactor][c/cfactor];
        }
    }
    return out;
}

public static void main(String[] args) throws Exception 
{
    // dein Beispiel:
    byte[][] byteArray =
        {{1, 0},
         {0, 1}};
    byte[][] newarray = stretch(byteArray, 10, 10);
    printMat(newarray);

    System.out.println();

    // kann jede Matrix um jede Dimension strecken:
    byte[][] byteArray2 =
        {{1, 2, 3},
         {4, 5, 6}};
    byte[][] newarray2 = stretch(byteArray2, 3, 2);
    printMat(newarray2);

}

Ausgabe:

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 1, 1, 1,