web-dev-qa-db-fra.com

Java: Vérifier si un bit est 0 ou 1 dans un long

Quelle méthode utiliseriez-vous pour déterminer si le bit qui représente 2 ^ x est 1 ou 0?

javalong-integerbit-shift
68
Ande TURNER

J'utiliserais:

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

(Vous pourrez peut-être vous en sortir avec moins de crochets, mais je ne me souviens jamais de la priorité des opérations au niveau du bit.)

166
Jon Skeet

Une autre alternative:

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

je me demande si:

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

  }

.. c'est mieux parce que peu importe si la valeur est longue ou non, ou si c'est pire parce que c'est moins évident.

Tom Hawtin - tackline 7 juillet à 14:16

14
Ande TURNER

Vous pouvez aussi utiliser

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

EDIT: la différence entre "(value>>x) & 1" Et "value & (1<<x)" dépend du comportement lorsque x est supérieur à la taille du type de "valeur" (32 dans votre cas).

Dans ce cas particulier, avec "(value>>x) & 1" Vous aurez le signe de valeur, tandis que vous obtenez un 0 avec "value & (1<<x)" (il est parfois utile d'obtenir le signe de bit si x est trop grande).

Si vous préférez avoir un 0 dans ce cas, vous pouvez utiliser l'opérateur ">>>", À la place si ">>"

Ainsi, "((value>>>x) & 1) != 0" Et "(value & (1<<x)) != 0" Sont complètement équivalents

12
ThibThib

Pour le nth LSB (bit le moins significatif), ce qui suit devrait fonctionner:

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

Vous voudrez peut-être consulter BitSet: http://Java.Sun.com/javase/6/docs/api/Java/util/BitSet.html

6
Yannick Motton

décalage de bit à droite de x et vérification du bit le plus bas.

4
schnaader

Dans Java ce qui suit fonctionne bien:

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

value et x peuvent être int ou long (et n'ont pas besoin d'être les mêmes).

Attention aux programmeurs non Java: l'expression précédente fonctionne en Java parce que dans cette langue les opérateurs de décalage de bit ne s'appliquent qu'au 5 (ou 6, au cas où de long) bits les plus bas de l'opérande de droite. Cela traduit implicitement l'expression en value << (~x & 31) (ou value << (~x & 63) si value est long).

Javascript: il fonctionne également en javascript (comme Java, seuls les 5 bits de décompte les plus bas sont appliqués). En javascript, tout number est de 32 bits.

En particulier en C, le nombre de décalages négatifs invoque un comportement indéfini, donc ce test ne fonctionnera pas nécessairement (bien qu'il le puisse, selon votre combinaison particulière de compilateur/processeur).

4
rslemos

La valeur du bit 2 ^ x est "variable & (1 << x)"

2
Artur Soler

déclarer un int int et le rendre égal à l'original. puis déplacez temp >> x fois, de sorte que le bit que vous souhaitez vérifier soit à la dernière position. puis faites temp & 0xf pour supprimer les bits précédents. Maintenant avec le dernier morceau. Enfin, faites si (y & 1 == 0), si le dernier bit est un 1, cela devrait être égal à 0, sinon sera égal à 1. C'est ça ou si (y + 0x1 == 0) ... pas trop sûr. faire le tour et voir

1
user1893702

Si quelqu'un n'est pas très à l'aise avec les opérateurs au niveau du bit, le code ci-dessous peut être essayé pour le décider par programme. Il y a deux façons.

1) Utilisez Java fonctionnalité de langage pour obtenir la chaîne de format binaire, puis vérifiez le caractère à une position spécifique

2) Continuez à diviser par 2 et décidez de la valeur du bit à une certaine 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;
}

Sortie

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

Ma contribution - ignorer la précédente

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 "); 
        }
    } 
}
0
Miguel Alonso Mosquera

J'ai codé une petite classe statique qui effectue certaines opérations sur les bits.

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

  }

S'il y a des questions qui circulent, écrivez-moi un e-mail.

Bonne programmation!

0
Alessandro Giusa