将整数组合成长整数

Question

我需要以某种方式将一系列 8 个整数连接成 Java 中的一个长整数。整数的值介于 0-255 之间。它们必须以这种方式组合：假设我们得到了这个整数样本（二进制）：

00000000 00000000 00000000 11111111

00000000 00000000 00000000 11111101

00000000 00000000 00000000 11110111

00000000 00000000 00000000 10111111

00000000 00000000 00000000 11110011

00000000 00000000 00000000 10111111

00000000 00000000 00000000 01111111

00000000 00000000 00000000 00111111

生成的浮点数必须是：

11111111 11111101 11110111 10111111 11110011 10111111 01111111 00111111

这在 Java 中是否可以以某种方式实现？我曾尝试使用字节而不是整数，但在 Java 中，字节（可能还有所有其他数据类型）是有符号的，所以我不得不将它们转换为整数，因为我无法处理负数，因为我需要将它们用作另一个函数中的参数。我有义务尝试以这种方式找到解决方案。任何帮助将不胜感激。

Answer 1

以下是帮助您构建自己的答案的构建基块：

1) 将整数的二进制表示形式获取为字符串：

Integer.toBinaryString(x)

2) 向左移动位模式 x、y 位：

x << y

3) 取2个等长的位模式x和y进行逻辑包含或运算：

x | y

4) 获取 long as 字符串的二进制表示：

Long.toBinaryString(x)

下面是一个可能的解决方案（带有显示输出的额外方法），基于定义的要求：

public class Integers {

    public static void main(String[] args) {
        Integers integers = new Integers();
        long result = integers.toLong(255, 253, 247, 191, 243, 191, 127, 63);
        System.out.println(integers.toBinaryStringWithPadding(result));
    }

    private long toLong(int... input) {
        if (input.length != 8) {
            throw new IllegalArgumentException();
        }

        long result = 0;

        for (int i = 0; i < input.length - 1; i++) {
            System.out.println(toBinaryStringWithPadding(input[i]) + "\n");
            result |= input[i];
            result <<= 8;
        }

        System.out.println(toBinaryStringWithPadding(input.length - 1) + "\n");
        result |= input[input.length - 1];

        return result;
    }

    private String toBinaryStringWithPadding(int value) {
        String binaryString = Integer.toBinaryString(value);
        int padding = 32 - binaryString.length();

        StringBuilder tmp = new StringBuilder(32 + 3);
        for (int i = 0; i < 32; i++) {
            if (i < padding) {
                tmp.append('0');
            } else {
                tmp.append(binaryString.charAt(i - padding));
            }

            if (i != 0 && (i + 1) % 8 == 0) {
                tmp.append(' ');
            }
        }

        return tmp.toString();
    }

    private String toBinaryStringWithPadding(long value) {
        String binaryString = Long.toBinaryString(value);
        int padding = 64 - binaryString.length();

        StringBuilder tmp = new StringBuilder(64 + 7);
        for (int i = 0; i < 64; i++) {
            if (i < padding) {
                tmp.append('0');
            } else {
                tmp.append(binaryString.charAt(i - padding));
            }

            if (i != 0 && (i + 1) % 8 == 0) {
                tmp.append(' ');
            }
        }

        return tmp.toString();
    }

}

Answer 2

我会做如下事情：

long  result = 0
int[] values = { 1, 2, 3, 4, 5, 6, 7, 8 }

for (int i = 0; i < values.length; i++)
    result |= values[i] << i*8;

|=是OR和set运算符，<<是左移，i*8是long中的偏移量.

Answer 3

您可以使用 ByteBuffer：

byte[] a = new byte[8];
a[0] = (byte) 255;
a[1] = (byte) 253;
a[2] = (byte) 247;
a[3] = (byte) 191;
a[4] = (byte) 243;
a[5] = (byte) 191;
a[6] = (byte) 127;
a[7] = (byte)  63;

ByteBuffer buffer = ByteBuffer.wrap(a);
System.out.println(buffer.getLong());
// Result:
// 11111111 11111101 11110111 10111111 11110011 10111111 01111111 00111111

另一种创建 ByteBuffer 的方法：

ByteBuffer buffer = ByteBuffer.allocate(Byte.SIZE);
buffer.put(0, (byte) 255);
buffer.put(1, (byte) 253);
// ...
buffer.put(7, (byte)  63);
System.out.println(buffer.getLong());

此外，您可以单独使用 getLong(...) 方法实现，而无需创建 ByteBuffer 实例：

long result = getLong(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]);
System.out.println(result);
// Result:
// 11111111 11111101 11110111 10111111 11110011 10111111 01111111 00111111

long getLong(byte b7, byte b6, byte b5, byte b4, byte b3, byte b2, byte b1, byte b0) {
    return ((((long) b7       ) << 56) |
            (((long) b6 & 0xff) << 48) |
            (((long) b5 & 0xff) << 40) |
            (((long) b4 & 0xff) << 32) |
            (((long) b3 & 0xff) << 24) |
            (((long) b2 & 0xff) << 16) |
            (((long) b1 & 0xff) <<  8) |
            (((long) b0 & 0xff)      ));
}

将整数组合成长整数

Combine integers into a long

java

integer

bit-manipulation

concatenation

long-integer