Java：用掩码检查二进制值，然后得到整数

我的问题是：

我有一个二进制值

101001

还有面具

011100

我想比较它们，得到一个整数的结果。在这种情况下，将给出：

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

= 010 => 2

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

我想比较它们，得到一个整数的结果

假设您的意思是“屏蔽”而不是“比较”：

int result = 0B011100 & 0B011100;

不需要字符数组

这是相当琐碎的

当然

你需要第一个和你的部分

向右移动以避免遮罩右侧的零

您需要的值已经是整数了

然后执行AND:

int masked=value&mask

然后向右移动，直到遮罩中的第一个1

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

您可以使用
while（mask&1==0）{
如果您愿意：）


我刚刚改进了算法，使其能够有一个可以拆分一位的掩码，例如：

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

private static long getMaskedValue（long maskedValue，long mask）{
长定义MaskedValue=0；
整数计数=0；
maskedValue=mask&maskedValue；
while（掩码！=0）{
而（（掩码&1）==0）{
掩码=掩码>>>1；
maskedValue=maskedValue>>>1；
}
而（（掩码&1）==1）{
定义maskedValue=定义maskedValue+（（maskedValue&1）>>1；
maskedValue=maskedValue>>>1；
}
}
返回确定性maskedvalue；
}

这是我的函数，通过位掩码将值存储在变量中，它返回旧变量，其中的值存储在其中。
我不得不使用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;
    }

private static long-setMaskedValue（long-maskedValue，long-mask，long-valueToAdd）{
int nbZero=0；
int nbLeastSignificantBit=0；
长tmpMask=掩码；
maskedValue=maskedValue&~mask；
while（tmpMask！=0）{
而（（tmpMask&1）==0）{
tmpMask=tmpMask>>>1；
nbLeastSignificantBit++；
nbZero++；
}
而（（tmpMask&1）==1）{
tmpMask=tmpMask>>>1；
BigInteger bigValueToAdd=BigInteger.valueOf（valueToAdd）.shiftLeft（nbZero）；
long tmpValueToAdd=bigValueToAdd.longValue（）；
BigInteger bigMaskOneBit=BigInteger.valueOf（1）.shiftLeft（NblestSignificantBit）；
long maskOneBit=bigMaskOneBit.longValue（）；
long bitValueToSet=getMaskedValue（tmpValueToAdd，maskOneBit）；
maskedValue=maskedValue | bitValueToSet但它不是2，应用掩码的结果将是
01000
-除非我遗漏了一些您知道的逻辑。我同意。但在我的情况下，我需要得到2。它可能不是位掩码，如果我使用了正确的词，我很抱歉…它不会返回010，尽管不清楚OP为什么想要结果lt shift.not some simple:System.out.println（“TEST:”+（28&41））；返回8！（01000）而不是2（010），因为需要右移以消除这两个零；-）就是这样！这似乎很明显，但我以前从未使用过移位运算符；）谢谢！我故意提到了我正在研究的假设。很明显，OP在他的问题中漏掉了一些东西。为什么在这样一个简单的问题上使用BigInt？只是浪费资源。处理特殊的角点移位32位的情况比使用BigInt要快得多做比金的数学
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;
    }