Question

所以我创建了很多byte []，我希望将其放在矩阵中，例如。 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);
    }

当我调用insert方法时，我希望将数组添加到正确的位置。所以从0,0然后0,1再到1,1 .... 3,3。所以我用..创建了代码。

   public void inserts(byte[] s){
        if(x ==y){
            buffer.get(x)[y]= s;
            System.out.println(y);
            y++;
        }
        else{
            buffer.get(x)[y]= s;
            System.out.println(x);
            x++;
        }
        counter++;
    }

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

有点像我犯了一个非常明显的错误，任何帮助都会很棒

谢谢

编辑：

数组数组的代码：

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

和插入

   private byte[][] buffer;
    private int x=0;
    private int y=0;

    public FixedBuffer(int BUFF_SIZE) {
        this.BUFF_SIZE = BUFF_SIZE;
        buffer = new byte[BUFF_SIZE][BUFF_SIZE];
    }


     public void inserts(byte[] s){
            if(x ==y){
                buffer.get(x)[y]= s;
                System.out.println(y);
                y++;
            }
            else{
                buffer.get(x)[y]= s;
                System.out.println(x);
                x++;
            }
            counter++;
        }

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

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

结构：

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

Answer 1

首先是一些测试代码。

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

arr = transpose(arr);
printRows(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 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");
}

转置的方法。采用hacky方式制作新的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 <byte []>矩阵并将其旋转

1 个答案: