Java中二维数组/矩阵的扩展

我有一个2x2矩阵存储在java的2D数组中

int pixels [][] = new int[2][2];

它以这种方式存储以下数据

{0 2}
{0 2}

我正在寻找一种方法来扩展此矩阵，例如，将其扩展为8x8矩阵，结果如下：

{0  0  0  0  2  2  2  2}
{0  0  0  0  2  2  2  2}
{0  0  0  0  2  2  2  2}
{0  0  0  0  2  2  2  2}
{0  0  0  0  2  2  2  2}
{0  0  0  0  2  2  2  2}
{0  0  0  0  2  2  2  2}
{0  0  0  0  2  2  2  2}

你知道如何使用Java实现这一点吗

这就是我迄今为止所尝试的：

int amountToExpand = finalImage.length/2;
     for(int i = 0; i<finalImage.length; i++){
         for(int j = 0; j<finalImage.length; j++){
             if(i < amountToExpand+1){
                 finalImage[i][j]=pixels[][];
             }
         }
     }

int-amountToExpand=finalImage.length/2；
对于（int i=0；i而言，关键在于最终图像中的单元格（i，j）包含前一图像中单元格（i/amountToExpand，j/amountToExpand）的值

如果amountToExpand的比率为整数，则此代码将运行良好

int amountToExpand = finalImage.length / pixels.length;
        for (int i = 0; i < finalImage.length; i++) {
            for (int j = 0; j < finalImage[i].length; j++) {
                finalImage[i][j] = pixels[i / amountToExpand][j / amountToExpand];
            }
        }

int-amountToExpand=finalImage.length/pixels.length；
对于（int i=0；i
关键是最终图像中的单元格（i，j）包含前一图像中单元格（i/amountToExpand，j/amountToExpand）的值

如果amountToExpand的比率为整数，则此代码将运行良好

int amountToExpand = finalImage.length / pixels.length;
        for (int i = 0; i < finalImage.length; i++) {
            for (int j = 0; j < finalImage[i].length; j++) {
                finalImage[i][j] = pixels[i / amountToExpand][j / amountToExpand];
            }
        }

int-amountToExpand=finalImage.length/pixels.length；
对于（int i=0；i
现在开始…expandArray用于展开和outputArray以显示数组的结果以供参考

public class Test {
    public static void main(String[] args) {
        try {
            int[][] pixels1 = new int[2][2];
            pixels1[0][0] = 1;
            pixels1[0][1] = 2;
            pixels1[1][0] = 3;
            pixels1[1][1] = 4;

            int[][] pixels2 = expandArray(pixels1, 4);

            outputArray(pixels1);
            outputArray(pixels2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static int[][] expandArray(int[][] arr, int factor) {
        int[][] output = new int[arr.length * factor][arr[0].length * factor];
        for (int i = 0; i < output.length; i++) {
            for (int j = 0; j < output[i].length; j++) {
                int orgRow = i / ((arr.length - 1) * factor);
                int orgCol = j / ((arr[0].length - 1) * factor);
                output[i][j] = arr[orgRow][orgCol];
            }
        }

        return output;
    }

    private static void outputArray(int[][] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }

            System.out.println();
        }
    }
}

公共类测试{
公共静态void main（字符串[]args）{
试一试{
int[][]像素1=新int[2][2]；
像素1[0][0]=1；
像素1[0][1]=2；
像素1[1][0]=3；
像素1[1][1]=4；
int[][]像素2=expandArray（像素1,4）；
输出阵列（像素1）；
输出阵列（像素2）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
专用静态int[]expandArray（int[]arr，int-factor）{
int[][]输出=新的int[arr.length*因子][arr[0]。length*因子]；
for（int i=0；i
现在开始…expandArray用于展开和outputArray以显示数组的结果以供参考

public class Test {
    public static void main(String[] args) {
        try {
            int[][] pixels1 = new int[2][2];
            pixels1[0][0] = 1;
            pixels1[0][1] = 2;
            pixels1[1][0] = 3;
            pixels1[1][1] = 4;

            int[][] pixels2 = expandArray(pixels1, 4);

            outputArray(pixels1);
            outputArray(pixels2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static int[][] expandArray(int[][] arr, int factor) {
        int[][] output = new int[arr.length * factor][arr[0].length * factor];
        for (int i = 0; i < output.length; i++) {
            for (int j = 0; j < output[i].length; j++) {
                int orgRow = i / ((arr.length - 1) * factor);
                int orgCol = j / ((arr[0].length - 1) * factor);
                output[i][j] = arr[orgRow][orgCol];
            }
        }

        return output;
    }

    private static void outputArray(int[][] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }

            System.out.println();
        }
    }
}

公共类测试{
公共静态void main（字符串[]args）{
试一试{
int[][]像素1=新int[2][2]；
像素1[0][0]=1；
像素1[0][1]=2；
像素1[1][0]=3；
像素1[1][1]=4；
int[][]像素2=expandArray（像素1,4）；
输出阵列（像素1）；
输出阵列（像素2）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
专用静态int[]expandArray（int[]arr，int-factor）{
int[][]输出=新的int[arr.length*因子][arr[0]。length*因子]；
for（int i=0；i
所以你想让每个数组元素重复4次，每个数组也重复4次？这很简单，但你做了什么try@Ramanlfc更新…这是我目前为止尝试的…@mtanti95让我们假设我的输入现在是一个4x4矩阵，但是，代码会如何更改？所以您希望每个数组元素4次，每个数组也要4次？这很简单向前走，但你做了什么try@Ramanlfc更新…这是我迄今为止尝试的…@mtanti95让我们假设我的输入现在是4x4矩阵，代码将如何更改？让我们假设我的输入现在是4x4矩阵，代码将如何更改？此代码仍然有效！如果新图像的大小是旧图像的倍数，则此代码将我工作。例如，我试过这个：01123 | 4567 | 8910111 | 1213141415 |它生成：0011233 | 01123 | 4455667 | 4455677 | 889910111 | 813131314141414 15 |让我们假设我的输入现在是一个4x4矩阵，代码将如何更改？此代码仍然有效！如果新图像的大小是旧图像的倍数，此代码将有效。例如，我尝试了以下方法：01 23 | 4 5 6 7 | 8 9 10 11 | 12 13 14 15 |，它生成：01 12 3 | 0 1 2 3 | 4 5 6 7 | 4 5 5 56  6  7  7  | 8  8  9  9  10 10 11 11 | 8  8  9  9  10 10 11 11 | 12 12 13 13 14 14 15 15 | 12 12 13 13 14 14 15 15 |