2

这是我的问题：

我有一个二进制值

101001

和一个面具

011100

我想比较它们并将结果作为整数。在这种情况下，这将给出：

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

= 010 => 2

我的第一个想法是处理一个字符数组。但我想知道是否有更好的方法可以在 Java 中实现这一目标？

4

3 回答 3

3

我想比较它们并将结果作为整数

假设您的意思是“掩码”而不是“比较”：

int result = 0B011100 & 0B011100;

不需要 char 数组。

这是相当微不足道的。

于 2012-09-18T08:57:09.787 回答
1

我刚刚改进了算法，使其能够在可以分割一个位的地方使用掩码，例如：

00111011011

这是我从掩码和掩码值中获取值的函数

 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;
    }

这是我通过位掩码将值存储在变量中的函数，它返回旧变量以及存储在其中的值。我不得不使用 BigInteger，因为移位运算符在 Java 中不能移动超过 32 位。

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;
    }
于 2012-12-17T09:11:35.410 回答
0

当然。

  1. 你需要先和你的位。
  2. 右移以避免掩码右侧的那些零。

您已经需要将值作为整数。

然后执行 AND：int masked = value & mask;

然后右移直到掩码中的第一个 1。

while (mask % 2 == 0) {
   mask = mask >>> 1;
   masked = masked >>> 1;
}

while (mask & 1 == 0) {如果您愿意，可以使用:)

& is bitwise AND.
| is bitwise OR.
^ is bitwise XOR (if my memory doesn't fail :).
>>> is shifting right (unsigned integer)
于 2012-09-18T08:59:18.923 回答