En Java, ¿puedo definir una constante entera en formato binario?

De forma similar a como se puede definir una constante entera en hexadecimal u octal, ¿puedo hacerlo en binario?

Admito que esta es una pregunta realmente fácil (y estúpida). Mis búsquedas de google están vacías.

Entonces, con el lanzamiento de Java SE 7, la notación binaria viene de fábrica. La syntax es bastante directa y obvia si tienes una comprensión decente del binario:

byte fourTimesThree = 0b1100; byte data = 0b0000110011; short number = 0b111111111111111; int overflow = 0b10101010101010101010101010101011; long bow = 0b101010101010101010101010101010111L; 

Y específicamente en el punto de declarar variables de nivel de clase como binarios, no hay ningún problema en inicializar una variable estática usando notación binaria:

 public static final int thingy = 0b0101; 

Solo tenga cuidado de no desbordar los números con demasiados datos, de lo contrario obtendrá un error de comstackción:

 byte data = 0b1100110011; // Type mismatch: cannot convert from int to byte 

Ahora, si realmente quieres ser elegante, puedes combinar esa nueva característica ordenada en Java 7 conocida como literales numéricos con guiones bajos. Echa un vistazo a estos elegantes ejemplos de notación binaria con guiones bajos literales:

 int overflow = 0b1010_1010_1010_1010_1010_1010_1010_1011; long bow = 0b1__01010101__01010101__01010101__01010111L; 

Ahora no es tan agradable y limpio, por no mencionar altamente legible?

Saqué estos fragmentos de código de un pequeño artículo que escribí sobre el tema en TheServerSide. No dudes en echarle un vistazo para más detalles:

Java 7 y notación binaria: dominio del examen OCP Java Programmer (OCPJP)

En Java 7:

 int i = 0b10101010; 

No hay literales binarios en las versiones anteriores de Java (ver otras respuestas para las alternativas).

No hay literales binarios en Java, pero supongo que puedes hacer esto (aunque no veo el punto):

 int a = Integer.parseInt("10101010", 2); 

La respuesta de Ed Swangren

 public final static long mask12 = Long.parseLong("00000000000000000000100000000000", 2); 

funciona bien. Utilicé long lugar de int y agregué los modificadores para aclarar el posible uso como máscara de bits. Sin embargo, hay dos inconvenientes con este enfoque.

  1. La tipificación directa de todos esos ceros es propensa a errores
  2. El resultado no está disponible en formato decimal o hexadecimal en el momento del desarrollo

Puedo sugerir un enfoque alternativo

 public final static long mask12 = 1L << 12; 

Esta expresión hace obvio que el 12º bit es 1 (el recuento comienza desde 0, de derecha a izquierda); y cuando coloca el cursor del mouse, la información sobre herramientas

 long YourClassName.mask12 = 4096 [0x1000] 

aparece en Eclipse Puede definir constantes más complicadas como:

 public final static long maskForSomething = mask12 | mask3 | mask0; 

o explícitamente

 public final static long maskForSomething = (1L<<12)|(1L<<3)|(1L<<0); 

El valor de la variable maskForSomething seguirá estando disponible en Eclipse en el momento del desarrollo.

Usar constantes binarias para enmascarar

Declarar constantes:

 public static final int FLAG_A = 1 << 0; public static final int FLAG_B = 1 << 1; public static final int FLAG_C = 1 << 2; public static final int FLAG_D = 1 << 3; 

y usarlos

 if( (value & ( FLAG_B | FLAG_D )) != 0){ // value has set FLAG_B and FLAG_D } 

Busque la “syntax de los literales de Java” en Google y obtendrá algunas entradas.

Hay una syntax octal (prefija su número con 0), syntax decimal y syntax hexadecimal con un prefijo “0x”. Pero no hay syntax para la notación binaria.

Algunos ejemplos:

 int i = 0xcafe ; // hexadecimal case int j = 045 ; // octal case int l = 42 ; // decimal case 

Si quieres jugar con muchos binarios, puedes definir algunas constantes:

 public static final int BIT_0 = 0x00000001; public static final int BIT_1 = 0x00000002; 

etc.

o

 public static final int B_00000001 = 0x00000001; public static final int B_00000010 = 0x00000002; public static final int B_00000100 = 0x00000004; 

Una respuesta un poco más incómoda:

 public class Main { public static void main(String[] args) { byte b = Byte.parseByte("10", 2); Byte bb = new Byte(b); System.out.println("bb should be 2, value is \"" + bb.intValue() + "\"" ); } } 

que salidas [java] bb deben ser 2, el valor es “2”