如何在java中将二维数组拆分为多个不同大小的二维数组

Question

我有一个称为像素的 6*6 二维数组

  int [][] pixels = { {1,2,7,9,4,11},
                    {3,4,6,6,12,12},
                    {4,9,15,14,9,9},
                    {10,10,20,18,8,8},
                    {4,3,17,16,1,4},
                    {4,5,18,18,5,6}
            };

我想像这样将它的数据存储到 9 个大小为 2*2 的二维数组中

 int [][] array1 = {{1,2},
            {3,4}
    };

    int [][] array2 = {{7,9},
            {6,6}
    };

    int [][] array3 = {{4,11},
            {12,12}
    };

像这样，我有另一个大小为 320 * 320 的二维数组，我想将其数据存储在 6400 个大小为 44 的二维数组中，但我不知道要动态做什么。我的 for 循环不正确。任何人都可以帮忙吗？ 编辑：我尝试了这段代码，它给了我正确的结果，重新分级了二维数组的第一个数组，但我不确定第二个数组。 vectorHeight 为 4。大的 2d 数组大小为 320 320，较小的数组大小为 4 * 4

for(int j=0; j < 320  ; j++){
            for(int i=0; i< 320 ; i++){
                int[][] array = new int[][]{
                        {pixels2[j * vectorHeight][i * vectorHeight], pixels2[j * vectorHeight][(i * vectorHeight) + 1],pixels2[j * vectorHeight][(i * vectorHeight) + 2],pixels2[j * vectorHeight][(i * vectorHeight) + 3]},
                        {pixels2[(j * vectorHeight) + 1][i * vectorHeight], pixels2[(j * vectorHeight) + 1][(i * vectorHeight) + 1],pixels2[(j * vectorHeight) + 2][(i * vectorHeight) + 2],pixels2[(j * vectorHeight) + 3][(i * vectorHeight) + 3]},
                };
                         System.out.println(Arrays.deepToString(array));
                }
            }

edit2：320 * 320 2d 数组是一个函数的结果，该函数获取图像并返回像素向量，因此这是读取图像的代码：

public static int[][] readImage(String filePath) {
        File file = new File(filePath);
        BufferedImage image = null;
        try {
            image = ImageIO.read(file);
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
        int width = image.getWidth();
        int height = image.getHeight();
        int[][] pixels = new int[height][width];
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                int p = image.getRGB(x, y);
                int a = (p >> 24) & 0xff;
                int r = (p >> 16) & 0xff;
                int g = (p >> 8) & 0xff;
                int b = p & 0xff;

                pixels[y][x] = r;

                p = (a << 24) | (r << 16) | (g << 8) | b;
                image.setRGB(x, y, p);
            }

        }

        return pixels;
    }

我目前正在处理的图像是这张https://www.researchgate.net/profile/Ayman-Al-Dmour/publication/304496637/figure/fig1/AS:377628822392833@1467045135613/Test-images_Q320.jpg 其余的代码是一个函数，它接受图像、向量大小（高度和重量），并最终假设使用向量量化对其进行压缩

int [][] pixels = readImage(filePath);
int numofVectors1 = (pixels.length * pixels.length) / (vectorHeight * vectorWidth);
        ArrayList<int[][]> vectors = new ArrayList<>(numofVectors1);
         for (int j = 0; j < pixels.length; j++) {
                for (int i = 0; i < pixels.length; i++) {
                    int[][] array = new int[][]{
                            {pixels[j * vectorHeight][i * vectorHeight], pixels[j * vectorHeight][(i * vectorHeight) + 1], pixels[j * vectorHeight][(i * vectorHeight) + 2], pixels[j * vectorHeight][(i * vectorHeight) + 3]},
                            {pixels[(j * vectorHeight) + 1][i * vectorHeight], pixels[(j * vectorHeight) + 1][(i * vectorHeight) + 1], pixels[(j * vectorHeight) + 1][(i * vectorHeight) + 2], pixels[(j * vectorHeight) + 1][(i * vectorHeight) + 3]},
                    };
                    vectors.add(array);
                }

        }

Answer 1

在您的情况下，写下您想要的内容会很有帮助：

         [0][0] [0][1] [1][0] [1][1]
         [0][2] [0][3] [1][2] [1][3]
         [0][4] [0][5] [1][4] [1][5]

         [2][0] [2][1] [3][0] [3][1]
         [2][2] [2][3] [3][2] [3][3]
         [2][4] [2][5] [3][4] [3][5]

         [4][0] [4][1] [5][0] [5][1]
         [4][2] [4][3] [5][2] [5][3]
         [4][4] [4][5] [5][4] [5][5]

也许您已经在这里看到了一种模式。 首先，我为前三行创建了内部循环：

for (int i = 0; i < 3; i++) {
    int[][] array = new int[][]{
            {pixels[0][i * 2], pixels[0][(i * 2) + 1]},
            {pixels[1][i * 2], pixels[1][(i * 2) + 1]}
    };
    System.out.println(Arrays.deepToString(array));
}

如您所见，它始终是前三行的第零行和第一行。 在接下来的三行中，它始终是第二行和第三行。 所有列的规则是它总是零、二、四和一、三、五。

所以说到嵌套循环：

for (int j = 0; j < 3; j++) {
    for (int i = 0; i < 3; i++) {
        int[][] array = new int[][]{
            {pixels[j * 2][i * 2], pixels[j * 2][(i * 2) + 1]},
            {pixels[(j * 2) + 1][i * 2], pixels[(j * 2) + 1][(i * 2) + 1]}};
        System.out.println(Arrays.deepToString(array));
    }
}

现在您可以将创建的数组存储在列表中。

编辑

对不起，我想我犯了一个错误。这应该做你想要的： 创建 6400 个 4x4 阵列。所以你必须循环直到你想要的数组数量的平方根（在本例中为 6400）。 你现在有可能检查数组是否正确吗？ 试试这个：

int vectorHeight = 4, vectorWidth = 4;
int numofVectors1 = (pixels.length * pixels.length) / (vectorHeight * vectorWidth);
ArrayList<int[][]> vectors = new ArrayList<>(numofVectors1);
int numberOfArrays = 6400;
        for (int j = 0; j < Math.sqrt(numberOfArrays); j++) {
            for (int i = 0; i < Math.sqrt(numberOfArrays); i++) {
                int[][] array = new int[][]{
                        {
                                pixels[j * vectorHeight][i * vectorHeight],
                                pixels[j * vectorHeight][(i * vectorHeight) + 1],
                                pixels[j * vectorHeight][(i * vectorHeight) + 2],
                                pixels[j * vectorHeight][(i * vectorHeight) + 3]
                        },
                        {
                                pixels[(j * vectorHeight) + 1][i * vectorHeight],
                                pixels[(j * vectorHeight) + 1][(i * vectorHeight) + 1],
                                pixels[(j * vectorHeight) + 1][(i * vectorHeight) + 2],
                                pixels[(j * vectorHeight) + 1][(i * vectorHeight) + 3]
                        },
                        {
                                pixels[(j * vectorHeight) + 2][i * vectorHeight],
                                pixels[(j * vectorHeight) + 2][(i * vectorHeight) + 1],
                                pixels[(j * vectorHeight) + 2][(i * vectorHeight) + 2],
                                pixels[(j * vectorHeight) + 2][(i * vectorHeight) + 3]
                        },
                        {
                                pixels[(j * vectorHeight) + 3][i * vectorHeight],
                                pixels[(j * vectorHeight) + 3][(i * vectorHeight) + 1],
                                pixels[(j * vectorHeight) + 3][(i * vectorHeight) + 2],
                                pixels[(j * vectorHeight) + 3][(i * vectorHeight) + 3]
                        },
                };
                vectors.add(array);
            }
        }