使用JAVA将大型2D数组拆分为多个较小的2D数组

我有一个2D数组，它由图像像素组成，其大小取决于输入图像的大小。我需要把它分成更小的9x9阵列。为了更清楚地说明情况，我尝试举例说明：

//smallerArray的行数和列数如下所示： 它应该从imagePixels数组中复制它们，遍历每8列，然后移动到下8行

    1st small   2nd small            3rd small            and so on..
    array:      array:               array: 
     012345678  91011121314151617   181920212223242526    ....
    0          0                   0
    1          1                   1
    2          2                   2
    3          3                   3
    4          4                   4
    5          5                   5
    6          6                   6
    7          7                   7
    8          8                   8

    Then move on to next 8 rows:

      012345678    91011121314151617   181920212223242526    ....
    9             9                   9
    10           10                  10
    11           11                  11
    12           12                  12
    13           13                  13
    14           14                  14
    15           15                  15
    16           16                  16
    17           17                  17

.
.
.

我已经完成了以下代码，但无法正确理解逻辑。如何停止迭代：

复制到第9列或第9行，将其存储在一个数组中，在第10列/第10行继续复制，在之后达到9列/第9行时停止，将其存储在另一个数组中，并继续执行此操作，直到完成对imagePixels数组的复制

我尝试将数组存储在ArrayList中，这样我就可以更容易地使用所有SmallerArray进行操作和计算

ArrayList<double[][]> collectionofSmallArrays = new ArrayList();
double[][] imagePixels = new double[1600][1000]; //Lets say this is the size of the image
double[][] smallerArray = new double[9][9];

for(int a = 0; a<smallerArray.length; a++)
{
  for(int b =0; b<smallerArray[a].length; b++)
  { 
    for(int c=0; c<imagePixels.length; c++)
    {
      for(int d=0; d<imagePixels[c].length; d++)
      {
        smallerArray[a][b] = imagePixels[c][d];
        ...(code to stop the iteration if it reaches 9, store it in array then resume where it stops     with another new array)
        collectionofSmallArrays.add(smallerArray);
      }
    }
  }
}

ArrayList collectionofSmallArrays=new ArrayList（）；
double[]imagePixels=新的double[1600][1000]//假设这是图像的大小
double[]Smallerray=新的double[9][9]；
对于（inta=0；a
smallerary[a][b]=imagePixels[c][d]
行看起来很奇怪。您重复使用了同一个数组实例。您的输出数组列表将包含对同一数组的多个引用。
您可能应该提供更多上下文信息。如果说一个包含
双值的数组表示像素，听起来很奇怪。如果您正在处理图像，那么您可能会在completel上找到解决方案y不同的抽象层次（我在这里思考）

但是，要回答这个问题，您应该将任务分解为更小的部分。特别是，实现两种方法可能更容易：


一种方法，用于接收输入数组、某些坐标和输出数组，并将数据从输入数组的指定坐标复制到输出数组
一种方法，使用适当的坐标调用上述方法，以将整个数组分割为所需大小的部分

在伪代码中：

for (each coordinates (9*r,9*c)) {
    copy the rectange (9*r,9*c)-(9*r+9,9*c+9) of the input array into an array

下面的示例中显示了一个非常简单的实现/测试。请注意，这可以推广和改进，但我认为它显示了基本思想：

import java.util.ArrayList;
import java.util.List;

public class SubArrayTest
{
    public static void main(String[] args)
    {
        double inputArray[][] = createInputArray(160, 100);
        System.out.println("inputArray: "+toString(inputArray));

        List<double[][]> subArrays = createSubArrays(inputArray, 9, 9);

        for (double subArray[][] : subArrays)
        {
            System.out.println("subArray:\n"+toString(subArray));
        }
    }

    private static List<double[][]> createSubArrays(
        double inputArray[][], int subRows, int subCols)
    {
        List<double[][]> subArrays = new ArrayList<double[][]>();
        for (int r=0; r<inputArray.length; r+=subRows)
        {
            for (int c=0; c<inputArray[r].length; c+=subCols)
            {
                double subArray[][] = new double[subRows][subCols]; 
                fillSubArray(inputArray, r, c, subArray);
                subArrays.add(subArray);
            }
        }
        return subArrays;
    }

    private static void fillSubArray(
        double[][] inputArray, int r0, int c0, double subArray[][])
    {
        for (int r=0; r<subArray.length; r++)
        {
            for (int c=0; c<subArray[r].length; c++)
            {
                int ir = r0 + r;
                int ic = c0 + c;
                if (ir < inputArray.length &&
                    ic < inputArray[ir].length)
                {
                    subArray[r][c] = inputArray[ir][ic];
                }
            }
        }
    }


    //===Test methods=========================================================
    private static double[][] createInputArray(int rows, int cols)
    {
        double array[][] = new double[rows][cols]; 
        for (int r=0; r<array.length; r++)
        {
            for (int c=0; c<array[r].length; c++)
            {
                array[r][c] = r*100+c;
            }
        }
        return array;
    }

    private static String toString(double array[][])
    {
        String format = "%7.1f";
        StringBuilder sb = new StringBuilder();
        for (int r=0; r<array.length; r++)
        {
            for (int c=0; c<array[r].length; c++)
            {
                sb.append(String.format(format, array[r][c])+" ");
            }
            sb.append("\n");
        }
        return sb.toString();
    }


}

import java.util.ArrayList；
导入java.util.List；
公共类子阵列测试
{
公共静态void main（字符串[]args）
{
双输入阵列[][]=createInputArray（160100）；
System.out.println（“inputArray:+toString（inputArray））；
列表子阵列=创建子阵列（输入阵列，9，9）；
对于（双子阵列[][]：子阵列）
{
System.out.println（“子数组：\n”+toString（子数组））；
}
}
私有静态列表子数组(
双输入阵列[][]，整数子线程，整数子线程）
{
列表子数组=新的ArrayList（）；
对于（int r=0；r
无法重用
smallerArray
。请在for循环中创建实例，并将大小存储在常量中
我认为一张带有一些角坐标作为键的地图要比一张存储结果的列表要好得多
如果图像的长度或宽度不能被9整除，会发生什么情况
首先，你需要决定你想要什么样的输出。我知道。这就是我要问的问题。我如何停止迭代并在新数组上继续。在循环中创建新数组。而且你的循环很奇怪。你能试着解释一下你认为它是如何工作的吗？是的，它看起来很奇怪，因为我无法正确理解我的逻辑。我在代码JU中包含了这个问题我不想让你们都大致了解我在做什么。基本上，我正在尝试使用9x9块将imagePixels数组分割成更小的数组。是的，我明白了。但在我看来，你们不理解循环是如何工作的。我试图理解我将尝试开始回答的要点。有一个代码块用于处理不可分割的图像9在前面的代码中，我没有包括在这个问题中。我很难将大数组分解成更小的数组。
ArrayList<String> x = new ArrayList<String>();

List<String> x = new ArrayList<String>();