Imprimir um número inteiro em formato binário em Java

Eu tenho um número e quero imprimi-lo em binário. Não quero fazer isso escrevendo um algoritmo. Existe alguma função interna para isso em Java?

Supondo que você queira dizer "embutido":

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

Consulte a documentação inteira .

( Longpossui um método semelhante, BigIntegerpossui um método de instância em que você pode especificar a raiz.)

Aqui não é necessário depender apenas do formato binário ou de qualquer outro formato ... Está disponível uma função flexível embutida Que imprime o formato que você deseja no seu programa. Integer.toString (int, representação);

Integer.toString(100,8) // prints 144 --octal representation

Integer.toString(100,2) // prints 1100100 --binary representation

Integer.toString(100,16) //prints 64 --Hex representation

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

Eu precisava de algo para imprimir bem as coisas e separar os bits a cada n-bit. Em outras palavras, exiba os zeros à esquerda e mostre algo como isto:

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

Então aqui está o que eu escrevi:

/**
 * 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();
}

Invoque-o assim:

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

Moda antiga:

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

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(0xFF & b)).replaceAll(" ", "0"));

}

Resultado:

i: 00000000000000000000000000001101
s: 0000000000001101
b: 00001101

confira esta lógica pode converter um número em qualquer 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));
    }
}

OU

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());

Essa é a maneira mais simples de imprimir a representação binária interna de um número inteiro. Por exemplo : Se considerarmos n como 17, a saída 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();
}

Simplesmente tente. Se o escopo estiver imprimindo apenas os valores binários do valor inteiro fornecido. Pode ser positivo ou negativo.

      public static void printBinaryNumbers(int n) {
        char[] arr = Integer.toBinaryString(n).toCharArray();
        StringBuilder sb = new StringBuilder();
        for (Character c : arr) {
          sb.append(c);
        }
        System.out.println(sb);
      }

entrada

5

Resultado

101

Solução usando máscara de exibição de 32 bits,

public static String toBinaryString(int n){

    StringBuilder res=new StringBuilder();
    //res= Integer.toBinaryString(n); or
    int displayMask=1<<31;
    for (int i=1;i<=32;i++){
        res.append((n & displayMask)==0?'0':'1');
        n=n<<1;
        if (i%8==0) res.append(' ');
    }

    return res.toString();
}


 System.out.println(BitUtil.toBinaryString(30));


O/P:
00000000 00000000 00000000 00011110 

Solução simples e muito mais fácil.

public static String intToBinaryString(int integer, int numberOfBits) {

    if (numberOfBits > 0) {     // To prevent FormatFlagsConversionMismatchException.

        String nBits = String.format("%" + numberOfBits + "s",      // Int to bits conversion
                Integer.toBinaryString(integer))
                .replaceAll(" ","0"); 

        return nBits;   // returning the Bits for the given int.
    }

    return null;        // if the numberOfBits is not greater than 0, returning null.
}

Já existem boas respostas postadas aqui para esta pergunta. Mas, é assim que eu tentei (e pode ser a lógica mais fácil com base → módulo / dividir / adicionar ):

        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

A questão é complicada em java (e provavelmente também em outro idioma).

Um número inteiro é um tipo de dados assinado de 32 bits , mas Integer.toBinaryString () retorna uma representação de seqüência de caracteres do argumento inteiro como um número inteiro não assinado na base 2.

Portanto, Integer.parseInt (Integer.toBinaryString (X), 2) pode gerar uma exceção (assinada versus não assinada).

A maneira segura é usar Integer.toString (X, 2); isso irá gerar algo menos elegante:

-11110100110

Mas funciona !!!

Eu acho que é o algoritmo mais simples até agora (para aqueles que não querem usar funções internas):

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

Exemplo:

convertNumber (1) -> "0b1"

convertNumber (5) -> "0b101"

convertNumber (117) -> "0b1110101"

Como funciona: while-loop move um número para a direita (substituindo o último bit pelo penúltimo, etc), obtém o valor do último bit e o coloca no StringBuilder, repete até que não haja mais bits (é quando a = 0).

    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

    }

Tente desta maneira:

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

Representação binária de dado int x com zeros à esquerda:

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

Digite qualquer número decimal como uma entrada. Depois disso, operações como módulo e divisão para converter a entrada fornecida em número binário. Aqui está o código-fonte do programa Java para converter valores inteiros em binário e o número de bits desse binário para seu número decimal. O programa Java é compilado com êxito e executado em um sistema Windows. A saída do programa também é mostrada abaixo.

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

Como nenhuma resposta é aceita, talvez sua pergunta tenha sido sobre como armazenar um número inteiro em um arquivo binário. java.io.DataOutputStream pode ser o que você está procurando: https://docs.oracle.com/javase/8/docs/api/java/io/DataOutputStream.html

DataOutputStream os = new DataOutputStream(outputStream);
os.writeInt(42);
os.flush();
os.close();

Você pode usar a máscara de bits (1 << k) e executar a operação AND com o número! 1 << k tem um bit na posição k!

private void printBits(int x) {
    for(int i = 31; i >= 0; i--) {
        if((x & (1 << i)) != 0){
            System.out.print(1);
        }else {
            System.out.print(0);
        }
    }
    System.out.println();
}

Ele trabalha com valores assinados e não assinados, usando uma poderosa manipulação de bits e gera os primeiros zeros à esquerda.

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