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. Existe-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 Documentation entière .
(Long a une méthode similaire, BigInteger a une méthode d'instance où vous pouvez spécifier la base.)
Ici, nul besoin de dépendre uniquement du format binaire ou de tout autre format ... une fonction intégrée flexible est disponible. Elle permet d’imprimer le format souhaité dans votre programme.
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 et séparer les bits tous les n bits. En d'autres termes, affichez les zéros au début et affichez quelque chose comme ceci:
n = 5463
output = 0000 0000 0000 0000 0001 0101 0101 0111
Alors voici 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));
découvrez 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());
C’est le moyen le plus simple d’imprimer la représentation binaire interne d’un entier .Exemple: si n est égal à 17, le résultat sera: 0000 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();
}
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
Essayez-le simplement. Si la portée n'imprime que les valeurs binaires d'une 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
Sortie
101
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(0xFFFFFF & b)).replaceAll(" ", "0"));
}
Sortie:
i: 00000000000000000000000000001101
s: 0000000000001101
b: 00001101
Il y a déjà de bonnes réponses postées ici pour cette question. Mais c’est ce que j’ai essayé moi-même (et cela pourrait ê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
Représentation binaire de int x donné avec des zéros à gauche:
org.Apache.commons.lang3.StringUtils.leftPad(Integer.toBinaryString(x), 32, '0')
Entrez n'importe quel nombre décimal en tant qu'entrée. Après cela, des opérations comme modulo et division permettent de convertir l’entrée donnée en nombre binaire . Voici le code source du programme Java permettant de convertir les 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());
}
}
La solution la plus simple et la plus 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.
}
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
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 ça marche: while-loop déplace un numéro vers la droite (remplace le dernier bit par l'avant-dernier, etc.), obtient la valeur du dernier bit et la met dans StringBuilder, répète jusqu'à ce qu'il n'y ait plus de bits à gauche (c'est quand 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
}
La question est délicate en Java (et probablement aussi dans d’autres langues).
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 unsigned entier en base 2.
Ainsi, Integer.parseInt (Integer.toBinaryString (X), 2) peut générer une exception (signé ou non signé).
Le moyen le plus sûr consiste à utiliser Integer.toString (X, 2); cela va générer quelque chose de moins élégant:
-11110100110
Mais ça marche !!!