Question

此源代码将4x4数组拆分为2x2数组... 如何将2x2阵列的值恢复为4x4阵列？

public class testmatriks {
    private static Random generator = new Random();

    public static void main(String[] args) {
        double[][] mainArray = new double[4][4];
        double[][] subArray = new double[2][2];
        double[][] rubArray = new double[4][4];
        int value;
        for (int i = 0; i < mainArray.length; i++) {
            for (int j = 0; j < mainArray[0].length; j++) {
                value = generator.nextInt(255);
                mainArray[i][j] = value;
                System.out.print(mainArray[i][j] + "  ");
            }
            System.out.println("");
        }
        System.out.println("\n");
        System.out.println("pecah ke piksel 2x2 piksel");

        for (int row = 0; row < (mainArray.length); row += 2) {
            for (int column = 0; column < mainArray[0].length; column += 2) {
                for (int k = 0; k < 2; k++) {
                    for (int l = 0; l < 2; l++) {
                        subArray[k][l] = mainArray[row + k][column + l] * 2;
                        System.out.print(subArray[k][l] + " ");
                    }
                    System.out.println(" ");
                }
            }
        }
    }
}

This picture illustrates what I want

这张照片说明了我想要的东西。

Answer 1

这是您最初在4x4阵列中所拥有的内容：

[一个<子> 1 | B'的子> 1 | c ₁ | d <子> 1 ]
[α<子> 2 | B'的子> 2 | c ₂ | d <子> 2 ]
[α<子> 3 | B'的子> 3 | c ₃ | d <子> 3 ]
[α<子> 4 | B'的子> 4 | c ₄ | d <子> 4 ]

这就是您创建的2x2阵列中的内容：

[2 * c ₃ | 2 * d ₃]
[2 * c ₄ | 2 * d ₄]

当你说“恢复”时，不清楚将这些值放在这个4x4数组中的位置，所以我将使用用于创建2x2的4x4中的位置：

代码：

for (int r = 0; r < 2; r++) {
    for (int c = 0; c < 2; c++) {
        mainArray[r + 2][c + 2] = subArray[r][c];
    }
}

这应该是代码运行后的内容：

[一个<子> 1 | B'的子> 1 | ç<子> 1 | d <子> 1 ]
[α<子> 2 | B'的子> 2 | ç<子> 2 | d <子> 2 ]
[α<子> 3 | B'的子> 3 | c ₃ + c ₃ | d ₃ + d ₃]
[α<子> 4 | B'的子> 4 | c ₄ + c ₄ | d ₄ + d ₄]

为了将阵列拆分成更小的块，我想出了这个：

/**
* @param larger the larger array to be split into sub arrays of size chunksize
* @param chunksize the size of each sub array
* @precond chunksize > 0 && larger != null
* @throws ArrayIndexOutOfBoundsException, NullPointerException
*/
public static List<double[][]> chunks(double [][]larger, int chunksize) throws 
    ArrayIndexOutOfBoundsException, NullPointerException  {
    if (chunksize <= 0)
        throw new ArrayIndexOutOfBoundsException("Chunks must be atleast 1x1");
    int size = larger.length / chunksize * (larger[0].length / chunksize);
    List<double[][]> subArrays = new ArrayList<>();

    for (int c = 0; c < size; c++) {
        double[][] sub = new double[chunksize][chunksize];
        int startx = (chunksize * (c / chunksize)) % larger.length;
        int starty = (chunksize * c) % larger[0].length;

        if (starty + chunksize > larger[0].length) {
            starty = 0;
        }

        for (int row = 0; row < chunksize; row++) {
            for (int col = 0; col < chunksize; col++) {
                sub[row][col] = larger[startx + row][col + starty];
            }
        }
        subArrays.add(sub);
    }

    return subArrays;
}

~~我还没有测试过，但您可以使用已有的代码轻松测试它。~~

样本用法： http://ideone.com/D5Tdgs

将Java 2D阵列（4x4）拆分为较小的（2x2）并再次连接它们

1 个答案: