Java 创建ArrayList的矩阵<；字节[]>；然后旋转它

所以我创建了很多字节[]，我想放在一个矩阵中，比如3x3，所以9字节[]，我可以使用下面的方法相应地旋转它们

  // ARRAY LIST
    private static void transpose(ArrayList<byte[]> m) {
        for (int i = 0; i < m.size(); i++) {
            for (int j = i; j < m.get(0).length; j++) {
                byte x = m.get(i)[j];
                m.get(i)[j] = m.get(j)[i];
                m.get(j)[i] = x;
            }
        }
    }

    public static void swapRows(ArrayList<byte[]> m) {
        for (int i = 0, k = m.size() - 1; i < k; ++i, --k) {
            byte[] x = m.get(i);
            m.set(i, m.get(k));
            m.set(k, x);
        }
    }

    public static void rotateByNinetyToLeft(ArrayList<byte[]> m) {
        transpose(m);
        swapRows(m);
    }

    public static void rotateByNinetyToRight(ArrayList<byte[]> m) {
        swapRows(m);
        transpose(m);
    }

但它不允许我正确地执行插入。不确定是什么问题

感觉我犯了一个非常明显的错误，任何帮助都会很好

多谢各位

编辑：

数组的代码：

private static void transposeb(byte[][] m) {

    for (int i = 0; i < m.length; i++) {
        for (int j = i; j < m[0].length; j++) {
            byte x = m[i][j];
            m[i][j] = m[j][i];
            m[j][i] = x;
        }
    }
}

public static void swapRowsb(byte[][] m) {
    for (int i = 0, k = m.length - 1; i < k; ++i, --k) {
        byte[] x = m[i];
        m[i] = m[k];
        m[k] = x;
    }
}

public static void rotateByNinetyToLeftb(byte[][] m) {
    transposeb(m);
    swapRowsb(m);
}

public static void rotateByNinetyToRightb(byte[][] m) {
    swapRowsb(m);
    transposeb(m);
}

byte[], byte[], byte[]
byte[], byte[], byte[]
byte[], byte[], byte[]

假设我们有一个3×3的向量

我想使用inserts（）添加所有字节[]，总共有9个。所以9字节[]，每次我加一个，索引的（x和y）变化

结构：

private static void transposeb(byte[][] m) {

    for (int i = 0; i < m.length; i++) {
        for (int j = i; j < m[0].length; j++) {
            byte x = m[i][j];
            m[i][j] = m[j][i];
            m[j][i] = x;
        }
    }
}

public static void swapRowsb(byte[][] m) {
    for (int i = 0, k = m.length - 1; i < k; ++i, --k) {
        byte[] x = m[i];
        m[i] = m[k];
        m[k] = x;
    }
}

public static void rotateByNinetyToLeftb(byte[][] m) {
    transposeb(m);
    swapRowsb(m);
}

public static void rotateByNinetyToRightb(byte[][] m) {
    swapRowsb(m);
    transposeb(m);
}

byte[], byte[], byte[]
byte[], byte[], byte[]
byte[], byte[], byte[]

首先是一些测试代码

ArrayList<byte[]> arr = new ArrayList<byte[]>(9);
initialize(arr);        
printRows(arr);

arr = transpose(arr);
printRows(arr);

ArrayList arr=新的ArrayList（9）；
初始化（arr）；
打印行（arr）；
arr=转置（arr）；
打印行（arr）；

使用随机测试数据初始化ArrayList

private static void initialize(ArrayList<byte[]> arr) {
    for(byte i = 0 ; i < 9 ; i++) {
        byte[] a = {i,i,i,i};
        arr.add(a);
    }
}

private静态无效初始化（ArrayList arr）{
用于（字节i=0；i<9；i++）{
字节[]a={i，i，i}；
arr.add（a）；
}
}

一种确定所有ops是否按要求工作的方法

private static void printRows(ArrayList<byte[]> arr) {
    int row = 0;
    for(int i = 0 ; i < arr.size() ; i++) {
        System.out.print(Arrays.toString(arr.get(i)) + "  ");
        row++;
        if(row%3 == 0)
            System.out.println();
    }
    System.out.println("\n\n");
}

private static void打印行（ArrayList arr）{
int行=0；
对于（int i=0；i

转置的方法。采用了一种新的ArrayList。请换一下。这只是为了说明逻辑

private static ArrayList<byte[]> transpose(ArrayList<byte[]> arr) {
    ArrayList<byte[]> newArr = new ArrayList<byte[]>(9);

    // fill with null
    for(int i = 0 ; i < 9 ; i++)
        newArr.add(null);

    for(int row = 0; row < 3 ; row++) {
        for(int col = 0 ; col < 3 ; col++) {
            // diagonal
            if(row == col) {
                newArr.add(row + 3*col, arr.get(row + 3*col));
            }

            int second = row + 3*col;       // elem at (row,col)
            int first = 3*row + col;        // elem at (col,row)

            // swap
            newArr.set(first, arr.get(second));
            newArr.set(second, arr.get(first)); 
        }
    }

    return newArr;
}

专用静态ArrayList转置（ArrayList arr）{
ArrayList newArr=新的ArrayList（9）；
//填充空值
对于（int i=0；i<9；i++）
newArr.add（空）；
对于（int行=0；行<3；行++）{
for（int col=0；col<3；col++）{
//对角线的
如果（行==列）{
newArr.add（行+3*col，arr.get（行+3*col））；
}
int second=row+3*col；//elem at（row，col）
int first=3*行+列；//元素位于（列，行）
//交换
newArr.set（第一，arr.get（第二））；
newArr.set（第二，arr.get（第一））；
}
}
返回newArr；
}

为什么要将Collections API（

ArrayList

）与数组混合使用？我要么使用一个数组（

byte[][]

），要么只使用一个大数组

byte[]

，然后计算偏移量（例如

matrix[y*width+x]

）。将ArrayList与数组混合是否不好？我最初使用的是byte[]]，但我无法让它工作，这就是我切换的原因，如果你愿意，我可以发布我的代码@DanielPrydenin除了好与坏的问题，我认为更多的是代码可读性和/或逻辑问题。使用字节数组的数组列表会使问题更加复杂。为什么不先使用一个数组，让事情顺利进行，然后根据需要转换为ArrayList呢？我认为这样做会更容易实现逻辑的万无一失。这就是@DebosmitRay的问题所在，这就是为什么我转向带有数组的ArrayList，因为我无法让它工作。我已经在编辑器中发布了数组数组的代码让我运行您的代码并返回给您。其他方法是否需要更改？是的。在另一种方法中还需要一些其他的修改。完成一些工作后，让我回到这个问题上来。谢谢，我现在要睡觉了。将在早上再次检查并接受您的回答编辑答案。我匆忙地做了这件事。因此，坏的风格。经测试，转置似乎按要求工作。请复制以进行交换。如果你需要帮助，请告诉我。正在使用ArrayList。@会话\u开始确认：）