Stampa un numero intero in formato binario in Java

Ho un numero e voglio stamparlo in binario. Non voglio farlo scrivendo un algoritmo, c'è qualche funzione integrata in Java?

Supponendo che intendi "integrato":

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

Vedi documentazione Intero .

( Longha un metodo simile, BigIntegerha un metodo di istanza in cui è possibile specificare la radice.)

Qui non c'è bisogno di dipendere solo dal binario o da qualsiasi altro formato ... è disponibile una funzione integrata flessibile che stampa il formato desiderato nel programma. Integer.toString (int, rappresentazione);

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

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

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

}

Produzione:

i: 00000000000000000000000000001101
s: 0000000000001101
b: 00001101

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 numero intero. Ad esempio : se prendiamo n come 17, l'output 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();
}

Provalo semplicemente. Se l'ambito stampa solo i valori binari del valore intero indicato. Può essere positivo o 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);
      }

ingresso

5

Produzione

101

Soluzione che utilizza una maschera di visualizzazione a 32 bit,

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 

Soluzione semplice e abbastanza semplice.

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

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

        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 è difficile in Java (e probabilmente anche in un'altra lingua).

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

Pertanto, Integer.parseInt (Integer.toBinaryString (X), 2) può generare un'eccezione (con segno o senza segno).

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 (ecco 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 dato int x con zeri imbottiti a sinistra:

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

Immettere un numero decimale come input. Dopodiché abbiamo operazioni come modulo e division per convertire l'input dato in numero binario. Ecco il codice sorgente del programma Java per convertire i valori interi in binario e il numero di bit di questo binario per il suo numero decimale. Il programma Java viene compilato correttamente ed eseguito su un sistema Windows. L'output del programma è anche mostrato di seguito.

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

Dal momento che nessuna risposta è accettata, forse la tua domanda era su come memorizzare un numero intero in un file binario. java.io.DataOutputStream potrebbe essere quello che stai cercando: https://docs.oracle.com/javase/8/docs/api/java/io/DataOutputStream.html

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

È possibile utilizzare la maschera di bit (1 << k) ed eseguire l'operazione AND con il numero! 1 << k ha un bit nella posizione 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();
}

Funziona con valori con segno e senza segno utilizzati con una potente manipolazione dei bit e genera i primi zero a 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();
    }