Java 位洗牌以改变小端的编码

所以在这个程序中，我需要从用户那里读取一个数字，这个数字需要从little endian编码改为用户想要改变的任何编码。用户输入的编码只是一个4位数字，这意味着编码后哪个字节应该在哪里。e、 4321表示将第四个字节放在第一位，然后是第三个字节，依此类推。编码可以采用其他形式，例如3214等

这是我的代码，如果有人指出我遗漏的地方，我将不胜感激

import java.util.Scanner;
 
class encoding {
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        String byteOrder = sc.next();

        long[] bitMask = { // little endian
            Long.parseLong("11111111000000000000000000000000", 2),
            Long.parseLong("00000000111111110000000000000000", 2),
            Long.parseLong("00000000000000001111111100000000", 2),
            Long.parseLong("00000000000000000000000011111111", 2)
        };

        int[] bytes = {
            (int)(bitMask[0] & n),
            (int)(bitMask[1] & n),
            (int)(bitMask[2] & n),
            (int)(bitMask[3] & n)
        };

        int result = 0;
        shuffleBytes(bytes, byteOrder);
        for (int i = 0; i < 4; i++) {
            bytes[i] = bytes[i] << (i * 8);
            result |= bytes[i];
        }

        System.out.println(result);
    }

    static void shuffleBytes(int[] bytes, String encoding) {
        for (int i = 0; i < 4; i++) {
            int index = Integer.parseInt(encoding.substring(i, i+1))-1;
            int copy = bytes[i];
            bytes[i] = bytes[index];
            bytes[index] = copy; 
        }
    }
}

import java.util.Scanner；
类编码{
公共静态void main（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
int n=sc.nextInt（）；
字符串字节顺序=sc.next（）；
long[]位掩码={//little-endian
Long.parseLong（“11111111 000000000000000000000000000000”，2），
Long.parseLong（“00000000 11111111 0000000000000000”，2），
Long.parseLong（“0000000000000000 111111100000000”，2），
Long.parseLong（“00000000000000000011111111”，2）
};
int[]字节={
（int）（位掩码[0]&n），
（int）（位掩码[1]&n），
（int）（位掩码[2]&n），
（int）（位掩码[3]&n）
};
int结果=0；
shuffleBytes（字节，字节顺序）；
对于（int i=0；i<4；i++）{
字节[i]=修复当前解决方案的字节[i]
有两个问题：

1.忘记右对齐字节
在

int[] bytes = {
    (int)(bitMask[0] & n),
    (int)(bitMask[1] & n),
    (int)(bitMask[2] & n),
    (int)(bitMask[3] & n)
};

static void shuffleBytes(int[] bytes, String encoding) {
    for (int i = 0; i < 4; i++) {
        int index = Integer.parseInt(encoding.substring(i, i+1))-1;
        int copy = bytes[i];
        bytes[i] = bytes[index];
        bytes[index] = copy; 
    }
}

…您忘记将每个“字节”向右移动。因此，您最终得到一个“字节”列表，其形式为
0x……000000，0x00……0000，0x0000……00，0x000000……
。这还不是问题，但在
shuffleBytes
之后，您将使用
bytes[i]=bytes[i]再次移动这些条目请通过ing将您遇到的问题添加到您的问题中。对于instace，请指定
n
和
byteOrder
的值、您从中得到的结果以及您的预期结果。对于严格反转，还有
整数。反转字节
static void shuffleBytes(int[] bytes, String encoding) {
    for (int i = 0; i < 4; i++) {
        int index = Integer.parseInt(encoding.substring(i, i+1))-1;
        int copy = bytes[i];
        bytes[i] = bytes[index];
        bytes[index] = copy; 
    }
}

static int[] shuffleBytes(int[] bytes, String encoding) {
    int[] result = new int[bytes.length];
    for (int i = 0; i < 4; i++) {
        int index = Integer.parseInt(encoding.substring(i, i+1))-1;
        result[index] = bytes[i]; 
    }
    return result; // also adapt main() to use this return value
}

import java.util.Scanner;
public class Encoding {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int input = sc.nextInt();
        System.out.format("input  = 0x%08x = %1$d%n", input);
        String newOrder = sc.next();
        int output = reorder(input, newOrder);
        System.out.format("output = 0x%08x = %1$d%n", output);
    }

    /** @param newOrder permutation of "1234" */
    static int reorder(int input, String newOrder) {
        int output = 0;
        for (char byte1Based : newOrder.toCharArray()) {
            output <<= 8;
            int shift = (byte1Based - '1') * 8;
            output |= ((0xFF << shift) & input) >> shift;
        }
        return output;
    }
}