Question

我有一个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列/行，当它达到9列/行后停止，将其存储在另一个数组中，并继续这样做直到它完成复制imagePixels数组。

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

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);
      }
    }
  }
}

任何人都可以解决代码以达到预期的效果吗？欣赏它。

Answer 1

您应该提供更多上下文信息。假设一个double值数组代表像素听起来是dubios。如果您正在使用图像，那么您可能会在完全不同的抽象级别上找到解决方案（我在这里考虑BufferedImage#createSubImage）。

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

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

在伪代码中：

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();
    }


}

附注：

您应该始终使用其接口类型声明变量。这意味着你不应该写

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

但总是

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

在发布的代码中，您似乎始终将子数组的相同实例添加到列表中。这意味着最终您将在列表中拥有相同数组的许多实例，所有实例都具有相同的内容。介于两者之间，你必须创建一个new double[9][9]数组。

Answer 2

smallerArray[a][b] = imagePixels[c][d]行看起来很奇怪。您重用相同的数组实例。您的输出数组列表将包含对同一数组的多个引用。

Answer 3

您无法重复使用smallerArray。在for循环中创建实例并将大小存储在常量中。
我认为将一些角坐标作为关键字的地图远比用于存储结果的列表好得多。
如果长度或宽度或图像不能被9整除，会发生什么？

使用JAVA将大型2D阵列分成多个较小的2D阵列

3 个答案: