Question

Here is my problem:

I have a binary value

101001

and a mask

011100

I would like to compare them and get the result as an integer. In this case that would give:

 1 **010** 01
 0 **111** 00

= 010 => 2

My first idea consists of dealing with a character array. But I would like to know if there is a better way to achieve this aim in Java?

Answer 1

I just improved the algorithm to be able to have mask where one bits can be splitted such as:

00111011011

Here is my function to get a value from a mask and a masked value

 private static long getMaskedValue(long maskedValue, long mask){
        long definitiveMaskedValue = 0;
        int count=0;

        maskedValue = mask & maskedValue;

        while (mask != 0){
            while ((mask & 1) == 0){
                mask = mask >>> 1;
                maskedValue = maskedValue >>> 1;
            }
            while ((mask & 1) == 1){
                definitiveMaskedValue = definitiveMaskedValue + ((maskedValue & 1) << count);
                count++;

                mask = mask >>> 1;
                maskedValue = maskedValue >>> 1;
            }
        }

        return definitiveMaskedValue;
    }

Here is my function to store a value in a variable thanks to a bitmask, it returns the old variable with the value stored inside.
I had to use BigInteger because of the shift operator that can not shift more than 32bits left in Java.

private static long setMaskedValue (long maskedValue, long mask, long valueToAdd) {
            int nbZero=0;
            int nbLeastSignificantBit=0;
            long tmpMask=mask;
            maskedValue = maskedValue & ~mask;

            while (tmpMask != 0){
                while ((tmpMask & 1) == 0){
                    tmpMask = tmpMask >>> 1;
                    nbLeastSignificantBit++;
                    nbZero ++;
                }

                while ((tmpMask & 1) == 1){
                    tmpMask = tmpMask >>> 1;

                    BigInteger bigValueToAdd = BigInteger.valueOf(valueToAdd).shiftLeft(nbZero);
                    long tmpValueToAdd = bigValueToAdd.longValue();
                    BigInteger bigMaskOneBit = BigInteger.valueOf(1).shiftLeft(nbLeastSignificantBit);
                    long maskOneBit = bigMaskOneBit.longValue();

                    long bitValueToSet = getMaskedValue(tmpValueToAdd, maskOneBit);
                    maskedValue = maskedValue | bitValueToSet << nbLeastSignificantBit;
                    nbLeastSignificantBit++;
                }
            }
        return maskedValue;
    }