Combine integers into long

Question

I need to somehow combine a series of 8 integers into one long Java. Integer values ​​are between 0-255. They should be combined in this way: Let's say we got this sample of integers (in binary format):

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

The resulting float should be:

11111111 11111101 11110111 10111111 11110011 10111111 01111111 00111111

- Java? , Java, (, , ) , , , . . .

Answer 1

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

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 - .

Answer 3

, :

1) :

Integer.toBinaryString(x)

2) x, y :

x << y

3) 2 x y :

x | y

4) :

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

}