Java: verificar se um pouco é 0 ou 1 em um longo

Question

Que método você usaria para determinar se o bit que representa 2^x é 1 ou 0?

Answer 1

Eu usaria:

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

(Você pode ser capaz de se safar com menos colchetes, mas nunca me lembro da precedência de operações bit -bowise.)

Answer 2

Outra alternativa:

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

Answer 3

Eu me pergunto se:

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

  }

.. é melhor porque não importa se o valor é longo ou não, ou se é pior porque é menos óbvio.

Tom Hawtin - Tackline 7 de julho às 14:16

Answer 4

Você também pode usar

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

Editar: a diferença entre "(value>>x) & 1" e "value & (1<<x)"depende do comportamento quando X é maior que o tamanho do tipo de" valor "(32 no seu caso).

Nesse caso em particular, com "(value>>x) & 1"Você terá o sinal de valor, enquanto você recebe um 0 com"value & (1<<x)"(Às vezes é útil obter o sinal de bit se X for muito grande).

Se você preferir ter um 0 nesse caso, você pode usar o ">>>"Operador, em vez disso, se">>"

Então, "((value>>>x) & 1) != 0" e "(value & (1<<x)) != 0"são completamente equivalentes

Answer 5

Para o nth thb (bit menos significativo), o seguinte deve funcionar:

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

Answer 6

Você pode querer conferir o Bitset: http://java.sun.com/javase/6/docs/api/java/util/bitset.html

Answer 7

Mudanças de bit Direito por X e verificando a parte mais baixa.

Answer 8

Em Java, o seguinte funciona bem:

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

value e x pode ser int ou long (e não precisa ser o mesmo).

Palavra de cautela para programadores não-Java: A expressão anterior funciona em Java, porque nesse idioma os operadores de mudança de bit se aplicam apenas aos 5 (ou 6, em caso de long) Bits mais baixos do operando do lado direito. Isso traduz implicitamente a expressão para value << (~x & 31) (ou value << (~x & 63) E se value é long).

JavaScript: Ele também funciona no JavaScript (como Java, apenas os 5 bits mais baixos de contagem de turnos são aplicados). Em JavaScript qualquer number é de 32 bits.

Particularmente em C, a contagem de turnos negativa chama o comportamento indefinido; portanto, esse teste não funcionará necessariamente (embora possa, dependendo da sua combinação específica de compilador/processador).

Answer 9

O valor do bit 2^x é "variável & (1 << x)"

Answer 10

Declare uma temp int e torne igual ao original. Em seguida, mude a temperatura >> x vezes, para que a parte que você deseja verificar está na última posição. Em seguida, faça temp & 0xf para soltar os bits anteriores. Agora saiu com o último bit. Finalmente, faça se (y & 1 == 0), se o último bit for um 1, que deve ser igual a 0, caso contrário, será igual a que ou se (y+0x1 == 0) ... não tem muita certeza. brincar e ver

Answer 11

Se alguém não se sentir muito confortável com os operadores bitwise, o código abaixo poderá ser tentado decidir programáticos. Existem duas maneiras.

1) Use a funcionalidade da linguagem Java para obter a string de formato binário e depois verifique o caractere na posição específica

2) Continue se dividindo por 2 e decida o valor do bit em determinada posição.

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

Resultado

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

Minha contribuição - ignore uma anterior

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

Codifiquei uma pequena classe estática que está fazendo algumas coisas de operação de 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;
  }

  }

Se houver algumas perguntas voando, apenas escreva -me um e -mail.

Boa programação!

Answer 14

Eliminar a mudança de bits e seus meandros e usar um Lut para a direita and operando.