wake-up-neo.com

Java: Überprüft, ob ein Bit in einem Long 0 oder 1 ist

Welche Methode würden Sie verwenden, um zu bestimmen, ob das Bit, das 2 ^ x darstellt, eine 1 oder 0 ist?

68
Ande TURNER

Ich würde verwenden:

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

(Möglicherweise können Sie mit weniger Klammern davonkommen, aber ich kann mich nie an den Vorrang bitweiser Operationen erinnern.)

166
Jon Skeet

Eine andere Alternative:

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

Ich frage mich ob:

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

  }

.. ist besser, weil es egal ist, ob der Wert lang ist oder nicht, oder schlimmer, weil er weniger offensichtlich ist.

Tom Hawtin - Tackline 7. Juli um 14:16

14
Ande TURNER

Sie können auch verwenden

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

BEARBEITEN: Der Unterschied zwischen "(value>>x) & 1" Und "value & (1<<x)" beruht auf dem Verhalten, wenn x größer ist als die Größe des Typs "value" (in Ihrem Fall 32).

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

Wenn Sie in diesem Fall eine 0 bevorzugen, können Sie stattdessen den Operator ">>>" Verwenden, wenn ">>"

"((value>>>x) & 1) != 0" Und "(value & (1<<x)) != 0" Sind also völlig gleichwertig

12
ThibThib

Für das nth LSB (niedrigstwertiges Bit) sollte Folgendes funktionieren:

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

Vielleicht möchten Sie BitSet auschecken: http://Java.Sun.com/javase/6/docs/api/Java/util/BitSet.html

6
Yannick Motton

Bitverschiebung rechts von x und Überprüfung des niedrigsten Bits.

4
schnaader

In Java funktioniert Folgendes einwandfrei:

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

value und x können int oder long sein (und müssen nicht gleich sein).

Achtung für Nicht-Java-Programmierer: Der vorstehende Ausdruck funktioniert in Java), da in dieser Sprache die Bitverschiebungsoperatoren nur für die 5 (oder 6, falls vorhanden) gelten von long) niedrigsten Bits des Operanden auf der rechten Seite. Dies übersetzt den Ausdruck implizit in value << (~x & 31) (oder value << (~x & 63), wenn valuelong).

Javascript: funktioniert auch in Javascript (wie in Java werden nur die niedrigsten 5 Bits der Schichtanzahl angewendet). In Javascript ist jedes number 32-Bit.

Insbesondere in C ruft die negative Verschiebungszahl ein undefiniertes Verhalten hervor, sodass dieser Test nicht unbedingt funktioniert (obwohl dies abhängig von Ihrer speziellen Kombination aus Compiler/Prozessor sein kann).

4
rslemos

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

2
Artur Soler

deklarieren Sie ein temporäres Int und machen Sie es gleich dem Original. Verschieben Sie dann temp >> x mal, sodass sich das zu überprüfende Bit an der letzten Position befindet. dann temp & 0xf, um die vorhergehenden Bits zu löschen. Jetzt mit dem letzten bisschen links. Schließlich tun, wenn (y & 1 == 0), wenn das letzte Bit eine 1 ist, das gleich 0 sein soll, sonst gleich 1. Entweder das oder wenn (y + 0x1 == 0) ... nicht zu sicher. herumalbern und sehen

1
user1893702

Wenn jemand mit bitweisen Operatoren nicht sehr vertraut ist, kann der folgende Code verwendet werden, um dies programmgesteuert zu entscheiden. Es gibt zwei Möglichkeiten.

1) Verwenden Sie die Sprachfunktionalität Java), um die Zeichenfolge im Binärformat abzurufen und dann das Zeichen an einer bestimmten Position zu überprüfen

2) Teilen Sie weiter durch 2 und legen Sie den Bitwert an einer bestimmten Position fest.

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
1
Kaushik Lele

Mein Beitrag - ignoriere den vorherigen

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

Ich habe eine kleine statische Klasse programmiert, die einige der Bitoperationsaufgaben erledigt.

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 Sie Fragen haben, schreiben Sie mir einfach eine E-Mail.

Gute Programmierung!

0