Suppressing sign-extension when upcasting or shifting in Java

Question

I have a feeling this is a rather trivial question, but I'm stumped. In my application I'm keying things in a lookup table with a pair of ints. I thought it would be easier to concatenate the two ints into one long and use the single long as a key instead. Coming from a C background, I was hoping something like this would work:

int a, b;
long l = (long)a << 32 | b;

My attempts to replicate this in Java have frustrated me. In particular, because there are no unsigned integral types, I can't seem to avoid the automatic sign-extension of b (a gets left-shifted so its irrelevant). I've tried using b & 0x00000000FFFFFFFF but it surprisingly has no effect. I also tried the rather ugly (long)b << 32 >> 32, but it seemed to be optimized out by the compiler.

I was hoping to do this strictly using bit manipulation with primitives, but I'm starting to wonder if I need to use some sort of buffer object to achieve this.

Answer 1

I always use my utility class with

public static long compose(int hi, int lo) {
    return (((long) hi << 32) + unsigned(lo));
}
public static long unsigned(int x) {
    return x & 0xFFFFFFFFL;
}

public static int high(long x) {
    return (int) (x>>32);
}
public static int low(long x) {
    return (int) x;
}

For any int x, y (negative or not)

high(compose(x, y)) == x
low(compose(x, y)) == y

holds and for any long z

compose(high(z), low(z)) == z

holds, too.