recursividad - Imprime un entero en formato binario en Java

convertir decimal a binario java netbeans

Question

Tengo un número y quiero imprimirlo en binario. No quiero hacerlo escribiendo un algoritmo. ¿Hay alguna función incorporada para eso en Java?

Answer 1

Aquí no es necesario depender solo del formato binario o de cualquier otro ... hay disponible una función integrada flexible que imprime el formato que desee en su programa. Integer.toString (int ,presentation);

Integer.toString(100,8) // prints 144 --octal representation
Integer.toString(100,2) // prints 1100100 --binary representation
Integer.toString(100,16) //prints 64 --Hex representation

Answer 2

Creo que es el algoritmo más simple hasta ahora (para aquellos que no quieren usar funciones integradas):

public static String convertNumber(int a) {
StringBuilder sb=new StringBuilder();
sb.append(a & 1);
while ((a>>=1) != 0) {
sb.append(a & 1);
}
sb.append("b0");
return sb.reverse().toString();
}

Ejemplo:

convertNumber (1) -> "0b1"

convertNumber (5) -> "0b101"

convertNumber (117) -> "0b1110101"

Cómo funciona: while-loop mueve un número a la derecha (reemplazando el último bit por el segundo a último, etc.), obtiene el último valor del bit y lo pone en StringBuilder, se repite hasta que no queda ningún bit (entonces es cuando a = 0).

Answer 3

Echa un vistazo a esta lógica puede convertir un número a cualquier base

public static void toBase(int number, int base) {
String binary = "";
int temp = number/2+1;
for (int j = 0; j < temp ; j++) {
try {
binary += "" + number % base;
number /= base;
} catch (Exception e) {
}
}
for (int j = binary.length() - 1; j >= 0; j--) {
System.out.print(binary.charAt(j));
}
}

O

StringBuilder binary = new StringBuilder();
int n=15;
while (n>0) {
if((n&1)==1){
binary.append(1);
}else
binary.append(0);
n>>=1;
}
System.out.println(binary.reverse());

Answer 4

Esta es la forma más sencilla de imprimir la representación binaria interna de un entero. Por ejemplo : Si tomamos n como 17, la salida será: 0000 0000 0000 0000 0000 0000 0001 0001

void bitPattern(int n) {
int mask = 1 << 31;
int count = 0;
while(mask != 0) {
if(count%4 == 0)
System.out.print(" ");
if((mask&n) == 0)
System.out.print("0");
else
System.out.print("1");
count++;
mask = mask >>> 1;
}
System.out.println();
}

Answer 5

Funciona con valores firmados y no firmados que utilizan una poderosa manipulación de bits y genera los primeros ceros a la izquierda.

public static String representDigits(int num) {
int checkBit = 1 << (Integer.SIZE * 8 - 2 ); // avoid the first digit
StringBuffer sb = new StringBuffer();
if (num < 0 ) { // checking the first digit
sb.append("1");
} else {
sb.append("0");
}
while(checkBit != 0) {
if ((num & checkBit) == checkBit){
sb.append("1");
} else {
sb.append("0");
}
checkBit >>= 1;
}
return sb.toString();
}

Answer 6

Intente de esta manera:

public class Bin {
public static void main(String[] args) {
System.out.println(toBinary(0x94, 8));
}
public static String toBinary(int a, int bits) {
if (--bits > 0)
return toBinary(a>>1, bits)+((a&0x1)==0?"0":"1");
else
return (a&0x1)==0?"0":"1";
}

}

10010100

Answer 7

Introduzca cualquier número decimal como entrada. Después de eso realizamos operaciones como módulo y división para convertir la entrada dada en un número binario. Aquí está el código fuente del programa Java para convertir valores enteros en binarios y el número de bits de este binario para su número decimal. El programa Java se compila con éxito y se ejecuta en un sistema Windows. La salida del programa también se muestra a continuación.

 public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int integer ;
String binary = ""; // here we count "" or null
// just String binary = null;
System.out.print("Enter the binary Number: ");
integer = sc.nextInt();
while(integer>0)
{
int x = integer % 2;
binary = x + binary;
integer = integer / 2;
}
System.out.println("Your binary number is : "+binary);
System.out.println("your binary length : " + binary.length());
}
}

Answer 8

La pregunta es difícil en java (y probablemente también en otro idioma).

Un entero es un tipo de datos con signo de 32 bits, pero Integer.toBinaryString () devuelve una representación de cadena del argumento entero como un entero sin signo en la base 2.

Por lo tanto, Integer.parseInt (Integer.toBinaryString (X), 2) puede generar una excepción (firmado vs. sin signo).

La forma segura es usar Integer.toString (X, 2); Esto generará algo menos elegante:

-11110100110

¡¡¡Pero funciona!!!

Answer 9

Necesitaba algo para imprimir las cosas bien y separar los bits cada n bits. En otras palabras, muestra los ceros iniciales y muestra algo como esto:

n = 5463
output = 0000 0000 0000 0000 0001 0101 0101 0111

Así que aquí está lo que escribí:

/**
* Converts an integer to a 32-bit binary string
* @param number
* The number to convert
* @param groupSize
* The number of bits in a group
* @return
* The 32-bit long bit string
*/
public static String intToString(int number, int groupSize) {
StringBuilder result = new StringBuilder();
for(int i = 31; i >= 0 ; i--) {
int mask = 1 << i;
result.append((number & mask) != 0 ? "1" : "0");
if (i % groupSize == 0)
result.append(" ");
}
result.replace(result.length() - 1, result.length(), "");
return result.toString();
}

Invocalo así:

public static void main(String[] args) {
System.out.println(intToString(5463, 4));
}

Answer 10

Representación binaria de int x dado con ceros rellenos a la izquierda:

org.apache.commons.lang3.StringUtils.leftPad(Integer.toBinaryString(x), 32, ''0'')

Answer 11

Suponiendo que te refieres a "incorporado":

int x = 100;
System.out.println(Integer.toBinaryString(x));

Ver la documentación del entero .

( Long tiene un método similar, BigInteger tiene un método de instancia en el que puede especificar el radix).

Answer 12

Vieja escuela:

 int value = 28;
for(int i = 1, j = 0; i < 256; i = i << 1, j++)
System.out.println(j + " " + ((value & i) > 0 ? 1 : 0));

Answer 13

Ya hay buenas respuestas publicadas aquí para esta pregunta. Pero, esta es la forma en que lo he intentado (y podría ser la lógica más sencilla basada en módulo / dividir / agregar ):

 int decimalOrBinary = 345;
StringBuilder builder = new StringBuilder();
do {
builder.append(decimalOrBinary % 2);
decimalOrBinary = decimalOrBinary / 2;
} while (decimalOrBinary > 0);
System.out.println(builder.reverse().toString()); //prints 101011001

Answer 14

 for(int i = 1; i <= 256; i++)
{
System.out.print(i + " "); //show integer
System.out.println(Integer.toBinaryString(i) + " "); //show binary
System.out.print(Integer.toOctalString(i) + " "); //show octal
System.out.print(Integer.toHexString(i) + " "); //show hex
}

Answer 15

System.out.println(Integer.toBinaryString(343));

Answer 16

public static void main(String[] args)
{
int i = 13;
short s = 13;
byte b = 13;
System.out.println("i: " + String.format("%32s",
Integer.toBinaryString(i)).replaceAll(" ", "0"));
System.out.println("s: " + String.format("%16s",
Integer.toBinaryString(0xFFFF & s)).replaceAll(" ", "0"));
System.out.println("b: " + String.format("%8s",
Integer.toBinaryString(0xFFFFFF & b)).replaceAll(" ", "0"));
}

Salida:

i: 00000000000000000000000000001101
s: 0000000000001101
b: 00001101