在java中移动长问题中的最高有效位

Question

[JAVA] I have a small problem, when clearing a bit from a long variable at a specific index.

The method works fine for nearly everything, but fails when i try to clear(set to 0) the msb (most significant bit).

public static long clear(long bitSet, int bitIndex) {

    bitSet &= ~(1L << bitIndex);


    return bitSet;
}

I really cant wrap my head around this error...

What am I doing wrong here?

Any help is greatly appreciated! Thanks in advance!!!

Example: if you put in 524552L it outputs 264L

in binary(same example): 10000000000100001000 --> 100001000

although it should output -- > 00000000000100001000

Answer 1

Try this.

public static final long setBits(final long store, final int startBitIndex, final int bitQuantity, final boolean MSBFormat, final boolean setBit)
{
        if(startBitIndex < 0 || startBitIndex > 63) throw new IndexOutOfBoundsException("startBitIndex must be at least 0 and cannot larger than 63.");
        if(bitQuantity < 0 || bitQuantity > 64) throw new IllegalArgumentException("bitQuantity must be at least 0 and cannot be larger than 64.");
        //Do not throw IndexOfOutBoundsException for bitQuantity > (64 - startBitIndex). Tolerate. Nothing's gained from that. Its binary after all.
        if(bitQuantity == 0) return store;
        if(MSBFormat && setBit) return ((startBitIndex > 31 ? store & 0xFFFFFFFF00000000L : ((((store >> 32) & 0xFFFFFFFFL) | ((0xFFFFFFFFL >> (32 - Math.min(bitQuantity, 32 - startBitIndex))) << Math.max(0, 32 - startBitIndex - bitQuantity))) << 32)) //left side
            | (startBitIndex + bitQuantity < 33 ? store & 0xFFFFFFFFL : ((store & 0xFFFFFFFFL) | ((0xFFFFFFFFL >> (32 - Math.min(bitQuantity, Math.min(32, 64 - startBitIndex)))) << Math.max(0, 32 - (bitQuantity - (32 - startBitIndex))))))); //right side
        if(MSBFormat) return ((startBitIndex > 31 ? store & 0xFFFFFFFF00000000L : ((((store >> 32) & 0xFFFFFFFFL) & ~((0xFFFFFFFFL >> (32 - Math.min(bitQuantity, 32 - startBitIndex))) << Math.max(0, 32 - startBitIndex - bitQuantity))) << 32)) //left side
            | (startBitIndex + bitQuantity < 33 ? store & 0xFFFFFFFFL : ((store & 0xFFFFFFFFL) & ~((0xFFFFFFFFL >> (32 - Math.min(bitQuantity, Math.min(32, 64 - startBitIndex)))) << Math.max(0, 32 - (bitQuantity - (32 - startBitIndex))))))); //right side
        if(setBit) return ((startBitIndex > 31 ? store & 0xFFFFFFFFL : (store & 0xFFFFFFFFL) | ((0xFFFFFFFFL >> (32 - Math.min(bitQuantity, 32 - startBitIndex))) << startBitIndex)) //right side
            | (startBitIndex + bitQuantity < 33 ? store & 0xFFFFFFFF00000000L : ((((store >> 32) & 0xFFFFFFFFL) | (0xFFFFFFFFL >> (32 - Math.min(bitQuantity, Math.min(32, bitQuantity + startBitIndex - 32))))) << 32))); //left side
        return ((startBitIndex > 31 ? store & 0xFFFFFFFFL : (store & 0xFFFFFFFFL) & ~((0xFFFFFFFFL >> (32 - Math.min(bitQuantity, 32 - startBitIndex))) << startBitIndex)) //right side
            | (startBitIndex + bitQuantity < 33 ? store & 0xFFFFFFFF00000000L : ((((store >> 32) & 0xFFFFFFFFL) & ~(0xFFFFFFFFL >> (32 - Math.min(bitQuantity, Math.min(32, bitQuantity + startBitIndex - 32))))) << 32))); //left side
}       
    
public static final long setMSBits(final long store, final int startBitIndex, final int bitQuantity)
{
    return setBits(store, startBitIndex, bitQuantity, true, true);
}

public static final long clearMSBits(final long store, final int startBitIndex, final int bitQuantity)
{
    return setBits(store, startBitIndex, bitQuantity, true, false);
}

public static final long setLSBits(final long store, final int startBitIndex, final int bitQuantity)
{
    return setBits(store, startBitIndex, bitQuantity, false, true);
}

public static final long clearLSBits(final long store, final int startBitIndex, final int bitQuantity)
{
    return setBits(store, startBitIndex, bitQuantity, false, false);
}