Drucken Sie eine Ganzzahl im Binärformat in Java

Ich habe eine Nummer und möchte sie binär ausdrucken. Ich möchte es nicht tun, indem ich einen Algorithmus schreibe. Gibt es eine integrierte Funktion dafür in Java?

Angenommen, Sie meinen "eingebaut":

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

Siehe Integer-Dokumentation .

( Longhat eine ähnliche Methode, BigIntegerhat eine Instanzmethode, mit der Sie den Radix angeben können.)

Hier müssen Sie sich nicht nur auf ein Binärformat oder ein anderes Format verlassen ... es steht eine flexible integrierte Funktion zur Verfügung, die das gewünschte Format in Ihrem Programm ausgibt. Integer.toString (int, Darstellung);

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

Ich brauchte etwas, um die Dinge schön auszudrucken und die Bits jedes n-Bit zu trennen. Mit anderen Worten, zeigen Sie die führenden Nullen an und zeigen Sie ungefähr Folgendes:

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

Also hier ist was ich geschrieben habe:

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

Rufen Sie es so auf:

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

Alte Schule:

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

}

Ausgabe:

i: 00000000000000000000000000001101
s: 0000000000001101
b: 00001101

Schauen Sie sich diese Logik an, um eine Zahl in eine beliebige Basis umzuwandeln

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

ODER

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

Dies ist die einfachste Methode zum Drucken der internen Binärdarstellung einer Ganzzahl. Zum Beispiel : Wenn wir n als 17 nehmen, lautet die Ausgabe: 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();
}

Probieren Sie es einfach aus. Wenn der Bereich nur die Binärwerte des angegebenen ganzzahligen Werts druckt. Es kann positiv oder negativ sein.

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

Eingang

5

Ausgabe

101

Lösung mit 32-Bit-Anzeigemaske,

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 

Einfache und ziemlich einfachste Lösung.

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

Hier gibt es bereits gute Antworten auf diese Frage. Aber so habe ich es selbst versucht (und es könnte die einfachste logikbasierte sein → modulo / dividieren / addieren ):

        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

Die Frage ist in Java (und wahrscheinlich auch in einer anderen Sprache) schwierig.

Eine Ganzzahl ist ein vorzeichenbehafteter 32-Bit- Datentyp, aber Integer.toBinaryString () gibt eine Zeichenfolgendarstellung des Ganzzahlarguments als vorzeichenlos zurück Ganzzahl in Basis 2 zurück.

Integer.parseInt (Integer.toBinaryString (X), 2) kann also eine Ausnahme generieren (signiert oder nicht signiert).

Der sichere Weg ist die Verwendung von Integer.toString (X, 2); Dies wird etwas weniger Elegantes erzeugen:

-11110100110

Aber es funktioniert!!!

Ich denke, es ist der bisher einfachste Algorithmus (für diejenigen, die keine integrierten Funktionen verwenden möchten):

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

Beispiel:

convertNumber (1) -> "0b1"

convertNumber (5) -> "0b101"

convertNumber (117) -> "0b1110101"

So funktioniert es: while-Schleife verschiebt eine Zahl nach rechts (Ersetzen des letzten Bits durch vorletztes Bit usw.), ruft den Wert des letzten Bits ab und legt ihn in StringBuilder ab. Wiederholt, bis keine Bits mehr vorhanden sind (dann 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

    }

Versuchen Sie Folgendes:

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

Binäre Darstellung des gegebenen int x mit links aufgefüllten Nullen:

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

Geben Sie eine beliebige Dezimalzahl als Eingabe ein. Danach arbeiten wir wie Modulo und Division, um die angegebene Eingabe in eine Binärzahl umzuwandeln. Hier ist der Quellcode des Java-Programms zum Konvertieren von Ganzzahlwerten in Binärwerte und die Bitnummer dieser Binärzahl für seine Dezimalzahl. Das Java-Programm wurde erfolgreich kompiliert und auf einem Windows-System ausgeführt. Die Programmausgabe wird auch unten gezeigt.

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

Da keine Antwort akzeptiert wird, war Ihre Frage möglicherweise, wie eine Ganzzahl in einer Binärdatei gespeichert werden kann. java.io.DataOutputStream könnte das sein, wonach Sie suchen: https://docs.oracle.com/javase/8/docs/api/java/io/DataOutputStream.html

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

Sie können die Bitmaske (1 << k) verwenden und eine UND-Operation mit der Nummer ausführen! 1 << k hat ein Bit an k Position!

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

Es funktioniert mit vorzeichenbehafteten und vorzeichenlosen Werten, die eine leistungsstarke Bitmanipulation verwenden, und generiert die ersten Nullen auf der linken Seite.

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