Stampa un numero intero in formato binario in Java

Ho un numero e voglio stamparlo in binario. Non voglio farlo scrivendo un algoritmo, esiste una funzione integrata per questo in Java?

Supponendo che tu intenda “built-in”:

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

Vedi la documentazione di Integer .

( Long ha un metodo simile, BigInteger ha un metodo di istanza in cui è ansible specificare la radice.)

Qui non c’è bisogno di dipendere solo da binari o da qualsiasi altro formato … è disponibile una funzione integrata flessibile che stampa qualunque formato tu voglia nel tuo programma. Integer.toString (int, representation);

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

Avevo bisogno di qualcosa per stampare bene le cose e separare i bit ogni n-bit. In altre parole, visualizza gli zeri iniziali e mostra qualcosa del genere:

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

Quindi ecco cosa ho scritto:

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

Richiamalo in questo modo:

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

Vecchia scuola:

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

controlla questa logica può convertire un numero in qualsiasi 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()); 

Questo è il modo più semplice di stampare la rappresentazione binaria interna di un intero. Ad esempio : Se prendiamo n come 17, l’uscita sarà: 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(); } 

Ci sono già buone risposte pubblicate qui per questa domanda. Ma, questo è il modo in cui mi sono provato (e potrebbe essere la logica più semplice basata → modulo / divide / aggiungi ):

  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 

La domanda è complicata in java (e probabilmente anche in altre lingue).

Un intero è un tipo di dati con segno a 32 bit, ma Integer.toBinaryString () restituisce una rappresentazione di stringa dell’argomento intero come numero intero senza segno in base 2.

Quindi, Integer.parseInt (Integer.toBinaryString (X), 2) può generare un’eccezione (firmata e non firmata).

Il modo sicuro è usare Integer.toString (X, 2); questo genererà qualcosa di meno elegante:

-11.110,10011 milioni

Ma funziona !!!

Penso che sia l’algoritmo più semplice finora (per coloro che non vogliono usare le funzioni integrate):

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

Esempio:

convertNumber (1) -> “0b1”

convertNumber (5) -> “0b101”

convertNumber (117) -> “0b1110101”

Come funziona: while-loop sposta un numero a destra (sostituendo l’ultimo bit con penultimo, ecc.), Ottiene il valore dell’ultimo bit e lo inserisce in StringBuilder, si ripete fino a quando non rimangono più bit (quello è 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 } 

Prova in questo modo:

 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

Rappresentazione binaria di determinati int x con gli zeri inseriti a sinistra:

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

Funziona con valori firmati e non firmati, utilizza una potente manipolazione dei bit e genera i primi zeri sulla sinistra.

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