What is the best way to do java coding for these type of byte level operations?

Question

I am reading on some problems that are about optimization approaches.
In the problem how to sort numbers in a specific range the solution is to use a bitmap. And if a number can appear e.g. up to 10 times use to use half bytes to map the numbers and as counters to represent the number of occurences.
The concept I understand well. My problem is how to implement this in Java in a straightforward manner.

I am stuck on bit operations.
For example for the first part to increment the counter by 1, what I could think about was:

Locate the byte
E.g. bitValue[i]
Then do byte tmp = bitValue[i] & 0x0F to get the lower bits (if the counter is the low counter).
Then do tmp = tmp + 1 to increment by 1.
Then do bitValue[i] >> 2 to clear low end bits and then bitValue[i] <<2 to restore. Now we have the same high bits as the original and the low bits clear.
Then do bitValue[i] |= tmp to set low bits.
Now bitValue has the low bit counter incremented by 1. Right?

For the upper bit it would be the same process but for the upper bits.

Then when I have to check what is the number of the counter.

I thought to use bitmasks:
0x0 0x1 0x2 etc and use OR to check what is the current counter number.

All these seem to be too complicated. Am I on the right track? How are these operations addressed best in java coding?

Any input, guidance on this is highly welcome.

Answer 1

You're definitely on the right track. Here's some fleshed out code which increments the first four bits or second four bits of an int by a given amount.

Note that I use int here instead of byte. Even if your data is a byte it's usually much easier to work with it as an int. This is because java bitwise operators like | and & and << return int. So its easiest to work with your data as an int then cast back once you've done all your bit twiddling.

Also, if you need to deal with a large chunk of data (perhaps more than just the two counters you mention) on a per-bit level, you might consider taking a look at BitSet.

public class Test {
    public static void main(String[] args)
    {
        int counter = 0;

        // increment the low bits by 3 and high bits by 2
        counter = addLowBits( counter, 3 );
        counter = addHighBits( counter, 2 );

        // print the hex string to verify
        System.out.println( Integer.toHexString( counter ) );
        System.out.println( "Low Counter: " + ( counter & 0x0F ) );
        System.out.println( "High Counter: " + ( ( counter & 0xF0 ) >> 4 ) );
    }

    public static int addLowBits( int counter, int increment )
    {
        // get the low bits
        int low = counter & 0x0F;

        // increment by 1
        low = low + increment;

        // mask the high bits and insert new low bits
        counter = (counter & 0xF0) | low;

        return counter;
    }

    public static int addHighBits( int counter, int increment )
    {
        // now get high bits
        int high = ( counter & 0xF0 ) >> 4;

        // increment by 1
        high = high + increment;

        // mask the low bits and insert new high bits
        counter = (counter & 0x0F) | ( high << 4 );

        return counter;
    }
}