How to manipulate the bits in a long?

Question

I want to transform a long to binary code, then change some bits and get the long again. I have found this post Java long to binary but I still can't achieve what I want.

I think there is two ways to achieve my goal:

Going from long to bitset and to long again
Going from long to binary String and then to int array and then to long again

 public static long changeHalf(long x){
        int[] firstHalf = new int[32];
        int[] secondHalf = new int[32];
        int[] result = new int[64];


        String binaryOfLong = Long.toBinaryString(x);
        for (int i = 0; i < firstHalf.length; i++) {

        }

        for (int i = 0; i < secondHalf.length; i++) {
            result[i] = secondHalf[i];
        }
        for (int i = 0; i < firstHalf.length; i++) {
            result[i+32] = firstHalf[i];
        }

        String s = Arrays.toString(result);
        return Long.parseLong(s);
    }

`long` **are** binary. What do you mean by "change some bits"? — T.J. Crowder, Jun 10 '19 at 07:07
@T.J.Crowder I want to swap the first 32 bits with the last 32 bits — J.erome, Jun 10 '19 at 07:07
OK. I was worried that you try to use it to make 32bit and 64bit variables. — Yunnosch, Jun 10 '19 at 07:08
@J.erome - You've said "swap" but that's not what your code appears to do... — T.J. Crowder, Jun 10 '19 at 07:09
@T.J.Crowder I think in the two loops on `firstHalf/secondHalf` I do the swap — J.erome, Jun 10 '19 at 07:11

T.J. Crowder · Accepted Answer · 2019-06-10T07:27:57.970

Rather than converting a long to arrays of int, just use bitwise operations.

I want to swap the first 32 bits with the last 32 bits

That would be:

long result = ((x & 0xFFFFFFFF00000000l) >> 32) | ((x & 0x00000000FFFFFFFFl) << 32);

That masks off the first 32 bits, shifts them to the right, masks off the last 32 bits, shifts them to the left, and combines the result with | (OR).

Live example:

class Example
{
    public static void main (String[] args) throws java.lang.Exception
    {
        long x = 0x1000000020000000l;
        long result = ((x & 0xFFFFFFFF00000000l) >> 32) | ((x & 0x00000000FFFFFFFFl) << 32);
        System.out.printf("0x%016X\n", x);
        System.out.printf("0x%016X\n", result);
    }
}

Outputs:

0x1000000020000000
0x2000000010000000

More in the Bitwise and Bit Shift Operators tutorial.

Yes I have seen it right after, but I still have a question. If I give 12L, the result after the swap should be a big number like >1024 right ? But I still get 12 in return — J.erome, Jun 10 '19 at 07:18

How to manipulate the bits in a long?

1 Answers1