Imprimer un entier au format binaire en Java

J'ai un numéro et je veux l'imprimer en binaire. Je ne veux pas le faire en écrivant un algorithme, y a-t-il une fonction intégrée pour cela en Java?

En supposant que vous vouliez dire «intégré»:

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

Voir la documentation Integer .

( Longa une méthode similaire, BigIntegera une méthode d'instance où vous pouvez spécifier le radix.)

Ici, pas besoin de dépendre uniquement du format binaire ou de tout autre format ... une fonction intégrée flexible est disponible Qui imprime le format que vous voulez dans votre programme. Integer.toString (int, représentation);

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

J'avais besoin de quelque chose pour bien imprimer les choses et séparer les bits tous les n bits. En d'autres termes, affichez les zéros de tête et affichez quelque chose comme ceci:

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

Voici donc ce que j'ai écrit:

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

Invoquez-le comme ceci:

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

Vieille école:

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

}

Production:

i: 00000000000000000000000000001101
s: 0000000000001101
b: 00001101

vérifier cette logique peut convertir un nombre en n'importe quelle 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());

Il s'agit de la manière la plus simple d'imprimer la représentation binaire interne d'un entier. Par exemple : si nous prenons n comme 17, la sortie sera: 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();
}

Essayez-le. Si la portée n'imprime que les valeurs binaires de la valeur entière donnée. Cela peut être positif ou négatif.

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

contribution

5

Production

101

Solution utilisant un masque d'affichage 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 

Solution simple et assez simple.

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

Il y a déjà de bonnes réponses publiées ici pour cette question. Mais, c'est la façon dont je me suis essayé (et peut-être la logique la plus simple → 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 question est délicate en java (et probablement aussi dans une autre langue).

Un entier est un type de données signé 32 bits , mais Integer.toBinaryString () renvoie une représentation sous forme de chaîne de l'argument entier sous la forme d'un entier non signé dans la base 2.

Ainsi, Integer.parseInt (Integer.toBinaryString (X), 2) peut générer une exception (signée ou non signée).

Le moyen sûr consiste à utiliser Integer.toString (X, 2); cela va générer quelque chose de moins élégant:

-11110100110

Mais ça marche !!!

Je pense que c'est l'algorithme le plus simple à ce jour (pour ceux qui ne veulent pas utiliser les fonctions intégrées):

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

Exemple:

convertNumber (1) -> "0b1"

convertNumber (5) -> "0b101"

convertNumber (117) -> "0b1110101"

Comment cela fonctionne: la boucle while déplace un nombre vers la droite (en remplaçant le dernier bit par l'avant-dernier, etc.), obtient la valeur du dernier bit et la place dans StringBuilder, se répète jusqu'à ce qu'il ne reste plus de bits (c'est à ce moment que 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

    }

Essayez de cette façon:

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

Représentation binaire d'un int x donné avec des zéros remplis à gauche:

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

Entrez un nombre décimal comme entrée. Après cela, nous opérons comme modulo et division pour convertir l'entrée donnée en nombre binaire. Voici le code source du programme Java pour convertir des valeurs entières en binaire et le nombre de bits de ce binaire pour son nombre décimal. Le programme Java est correctement compilé et exécuté sur un système Windows. La sortie du programme est également indiquée ci-dessous.

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

Comme aucune réponse n'est acceptée, votre question était peut-être de savoir comment stocker un entier dans un fichier binaire. java.io.DataOutputStream pourrait être ce que vous recherchez: https://docs.oracle.com/javase/8/docs/api/java/io/DataOutputStream.html

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

Vous pouvez utiliser le masque de bits (1 << k) et faire une opération ET avec un nombre! 1 << k a un bit en position 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();
}

Il fonctionne avec des valeurs signées et non signées, utilise une puissante manipulation de bits et génère les premiers zéros à gauche.

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