Java: Überprüfen Sie, ob ein bisschen 0 oder 1 in langer Zeit ist

Question

Mit welcher Methode würden Sie feststellen, ob das Bit, das 2^x darstellt, 1 oder 0 ist?

Answer 1

Ich würde verwenden:

if ((value & (1L << x)) != 0)
{
   // The bit was set
}

(Möglicherweise können Sie mit weniger Klammern davonkommen, aber ich erinnere mich nie an den Vorrang der bitimen Operationen.)

Answer 2

Eine andere Alternative:

if (BigInteger.valueOf(value).testBit(x)) {
    // ...
}

Answer 3

Ich frage mich, ob:

  if (((value >>> x) & 1) != 0) {

  }

.. ist besser, weil es keine Rolle spielt, ob Wert lang ist oder nicht oder ob es schlimmer ist, weil er weniger offensichtlich ist.

Tom Hawtin - Tackline 7. Juli um 14:16 Uhr

Answer 4

Sie können auch verwenden

bool isSet = ((value>>x) & 1) != 0;

Bearbeiten: Der Unterschied zwischen "(value>>x) & 1" und "value & (1<<x)"stützt sich auf das Verhalten, wenn x größer ist als die Größe des" Wertes "(32 in Ihrem Fall).

In diesem speziellen Fall mit "(value>>x) & 1"Sie werden das Zeichen des Wertes haben, während Sie eine 0 erhalten"value & (1<<x)"(Es ist manchmal nützlich, das Bitzeichen zu erhalten, wenn x zu groß ist).

Wenn Sie in diesem Fall lieber eine 0 haben, können Sie die "verwenden">>>"Operator, stattdessen wenn">>"

So, "((value>>>x) & 1) != 0" und "(value & (1<<x)) != 0"sind völlig äquivalent

Answer 5

Für die nDas LSB (am wenigsten bedeutend) sollte Folgendes funktionieren:

boolean isSet = (value & (1 << n)) != 0;

Answer 6

Vielleicht möchten Sie sich BitSet ansehen: http://java.sun.com/javase/6/docs/api/java/util/bitset.html

Answer 7

Bit wechseln direkt mit x und das niedrigste Bit überprüfen.

Answer 8

In Java funktioniert die folgende Funktionen:

if (value << ~x < 0) {
   // xth bit set
} else {
   // xth bit not set
}

value und x kann sein int oder long (Und muss nicht gleich sein).

Vorsichtswort für Nicht-Java-Programmierer: Der vorhergehende Ausdruck funktioniert in Java, da in dieser Sprache die Bitschichtbetreiber nur für den 5 (oder 6, im Fall von long) Niedrigste Teile der rechten Seite Operanden. Dies übersetzt implizit den Ausdruck auf value << (~x & 31) (oder value << (~x & 63) wenn value ist long).

JavaScript: Es funktioniert auch in JavaScript (wie Java werden nur die niedrigsten 5 -Bit -Schichtzahl angewendet). In JavaScript alle number ist 32-Bit.

Insbesondere in C ruft die negative Verschiebungsanzahl ein definiertes Verhalten auf, sodass dieser Test nicht unbedingt funktioniert (obwohl dies abhängig von Ihrer speziellen Kombination von Compiler/Prozessor).

Answer 9

Der Wert des 2^x -Bits ist "Variable & (1 << x)".

Answer 10

deklarieren Sie eine Temperatur int und machen Sie es gleich das Original. Schalten Sie dann die Temperatur >> x Mal, damit das Bit, das Sie überprüfen möchten, an der letzten Position befindet. Dann machen Sie Temp & 0xf, um die vorhergehenden Bits fallen zu lassen. Jetzt bleibt mit dem letzten Stück. Schließlich tun Sie, wenn (y & 1 == 0), wenn das letzte Bit ein 1 ist, dies sollte 0 entsprechen, sonst gleich 1. Es ist entweder das oder wenn (y+0x1 == 0) ... nicht sicher. herumtarren und sehen

Answer 11

Wenn sich jemand mit bitgewiehenen Betreibern nicht sehr wohl fühlt, kann der folgende Code versucht werden, es programmatisch zu entscheiden. Es gibt zwei Möglichkeiten.

1) Verwenden Sie die Java -Sprachfunktionalität, um die Binärformatzeichenfolge zu erhalten und das Zeichen anschließend an einer bestimmten Position zu überprüfen

2) Teilen Sie weiter 2 und entscheiden Sie den Bitwert an einer bestimmten Position.

public static void main(String[] args) {
    Integer n =1000;
    String binaryFormat =  Integer.toString(n, 2);
    int binaryFormatLength = binaryFormat.length();
    System.out.println("binaryFormat="+binaryFormat);
    for(int i = 1;i<10;i++){
        System.out.println("isBitSet("+n+","+i+")"+isBitSet(n,i));
        System.out.println((binaryFormatLength>=i && binaryFormat.charAt(binaryFormatLength-i)=='1'));
    }

}

public static boolean isBitSet(int number, int position){
    int currPos =1;
    int temp = number;
    while(number!=0 && currPos<= position){
        if(temp%2 == 1 && currPos == position)
            return true;
        else{
            temp = temp/2;
            currPos ++;
        }
    }
    return false;
}

Ausgabe

binaryFormat=1111101000
isBitSet(1000,1)false
false
isBitSet(1000,2)false
false
isBitSet(1000,3)false
false
isBitSet(1000,4)true
true
isBitSet(1000,5)false
false
isBitSet(1000,6)true
true
isBitSet(1000,7)true
true
isBitSet(1000,8)true
true
isBitSet(1000,9)true
true

Answer 12

Mein Beitrag - Ignorieren Sie die vorherige

public class TestBits { 

    public static void main(String[] args) { 

        byte bit1 = 0b00000001;     
        byte bit2 = 0b00000010;
        byte bit3 = 0b00000100;
        byte bit4 = 0b00001000;
        byte bit5 = 0b00010000;
        byte bit6 = 0b00100000;
        byte bit7 = 0b01000000;

        byte myValue = 9;                        // any value

        if (((myValue >>> 3) & bit1 ) != 0) {    //  shift 3 to test bit4
            System.out.println(" ON "); 
        }
    } 
}

Answer 13

Ich habe eine kleine statische Klasse codiert, die einige der Bit -Operation -Sachen macht.

public final class Bitfield {

  private Bitfield() {}

  // ********************************************************************
  // * TEST
  // ********************************************************************

  public static boolean testBit(final int pos, final int bitfield) {
      return (bitfield & (1 << pos)) == (1 << pos);
  }

  public static boolean testNum(final int num, final int bitfield) {
      return (bitfield & num) == num;
  }

  // ********************************************************************
  // * SET
  // ********************************************************************

  public static int setBit(final int pos, final int bitfield) {
     return bitfield | (1 << pos);
  }

  public static int addNum(final int number, final int bitfield) {
      return bitfield | number;
  }

  // ********************************************************************
  // * CLEAR
  // ********************************************************************

  public static int clearBit(final int pos, final int bitfield) {
      return bitfield ^ (1 << pos);
  }

  public static int clearNum(final int num, final int bitfield) {
      return bitfield ^ num;
  }

  }

Wenn es einige Fragen gibt, die herumfliegen, schreiben Sie mir einfach eine E -Mail.

Gute Programmierung!

Answer 14

Beseitigen Sie die Bitschiebe und ihre Feinheiten und verwenden Sie a Lut für das Recht and Operand.