Java表达式等效

Question

For Java how is:

long c = ((long)a << 32) | ((long)b & 0xFFFFFFFL);

equivalent to

long c = (long)a << 32
c+=b

The bit mask as I understand it will give back the original number itself and the OR and the addition operation are not equivalent. How then do these two implementations always give the same answer?

Answer 1

Bitwise OR is equivalent to addition, if the operands do not have any common bits.

For example:

0x123456780000000 + 0x12345678 = 0x1234567812345678
0x123456780000000 | 0x12345678 = 0x1234567812345678

If you just shifted a 32 bits to the left, there will be 32 zero bits on the right. Assuming b has only 32 bits you can safely do OR instead of addition.

Answer 2

They're not equivalent (unless you restrict the possible values of b ).

For example, if a == 1 and b == -1, the first expression results in 4563402751 and the second expression results in 4294967295 .

They will give the same result if you limit b to be >= 0 and <= 0xFFFFFFF (which is 2^28 - 1 ).

(long)a << 32 (assuming a is of a smaller primitive type than long ) shifts the bits of a 32 positions to the left.

Therefore if a was

                          xxx....xxxxxx

(long)a << 32 is

             xxx....xxxxxx000....000000 

Now if you perform bitwise OR between this number and any non-negative int , you'll get the same result as adding those two numbers, since the low 32 bits of (long)a << 32 are 0, so adding to it a number that only has 1 bits in its low 31 bits is the same as setting to 1 all the bits that are 1 in (long)a << 32 and all the bits the are 1 in the second number (which is equivalent to bitwise OR).

Answer 3

Let's look at the bits.

Suppose int is 1 byte (8 bits) and long is 2 bytes (16 bits).

The a << 32 becomes a << 8 and 0xFFFFFFFFL becomes 0xFFFFL :

Left part ( (long)a << 8 ):

Start:

bits: 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8
data: a a a a a a a a a a a a a a a a

Shift a << 8 :

                      <-  shifted  ->
bits: 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8
data: a a a a a a a a 0 0 0 0 0 0 0 0

Right part ((long)b & 0xFFFFL) :

Start:

bits: 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8
data: b b b b b b b b b b b b b b b b

After b & 0xFFFL :

      <- & with 0  -> <- & with 1  ->
bits: 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8
data: 0 0 0 0 0 0 0 0 b b b b b b b b

And now | (note that a and b do not "touch" each other!):

bits: 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8
data: 0 0 0 0 0 0 0 0 b b b b b b b b

bits: 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8
data: a a a a a a a a 0 0 0 0 0 0 0 0

Gives:

bits: 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8
data: a a a a a a a a b b b b b b b b

Note that this will probably work only for a subset of values (try positive and negative numbers), but the logic behind it is as I stated.

Answer 4

((long)b & 0xFFFFFFFFL) extracts the least significant 32 bits from b . ((long)a << 32) creates a long where the least significant 32 bits are 0. This way, the OR is equivalent to += .

I am not sure if this also works for negative values of b, though (two's complement).

Please note that long in Java has 64 bits.