Comment obtenir une représentation binary avec un nombre entier dans un entier en Java?

Par exemple, pour 1, 2, 128, 256 la sortie peut être (16 chiffres):

 0000000000000001 0000000000000010 0000000010000000 0000000100000000 

j’ai essayé

 Ssortingng.format("%16s", Integer.toBinarySsortingng(1)); 

il met des espaces pour le padding gauche:

 ` 1' 

Comment mettre 0 s pour le rembourrage. Je n’ai pas pu le trouver dans Formatter . Y a-t-il une autre façon de le faire?

Merci d’avance.

PS ce post décrit comment formater des entiers avec 0-padding à gauche, mais ce n’est pas pour la représentation binary.

Je pense que c’est une solution sous-optimale, mais vous pourriez faire

 Ssortingng.format("%16s", Integer.toBinarySsortingng(1)).replace(' ', '0') 

Il n’y a pas de conversion binary dans java.util.Formatter, je vous conseille d’utiliser soit Ssortingng.replace pour remplacer le caractère espace par des zéros, comme dans:

 Ssortingng.format("%16s", Integer.toBinarySsortingng(1)).replace(" ", "0") 

Ou implémentez votre propre logique pour convertir des entiers en représentation binary avec un remplissage à gauche quelque part selon les lignes données dans ce cas. Ou, si vous avez vraiment besoin de passer des nombres au format, vous pouvez convertir votre représentation binary en BigInteger, puis la formater avec des zéros non significatifs, mais cela est très coûteux à l’exécution, comme dans:

 Ssortingng.format("%016d", new BigInteger(Integer.toBinarySsortingng(1))) 

J’étais en train d’essayer toutes sortes d’appels de méthodes que je n’avais pas vraiment utilisé auparavant pour faire ce travail, ils ont fonctionné avec un succès modéré, jusqu’à ce que je pense à quelque chose de si simple que cela pourrait fonctionner, et c’est arrivé!

Je suis sûr que cela a été pensé avant, pas sûr que ce soit bon pour une longue chaîne de codes binarys, mais cela fonctionne très bien pour les chaînes de 16 bits. J’espère que cela aide!! (Notez que le deuxième morceau de code est amélioré)

 Ssortingng binSsortingng = Integer.toBinarySsortingng(256); while (binSsortingng.length() < 16) { //pad with 16 0's binString = "0" + binString; } 

Merci à Will pour avoir aidé à améliorer cette réponse pour la faire fonctionner en boucle. C'est peut-être un peu maladroit mais ça marche, veuillez améliorer et commenter si vous le pouvez ....

 binSsortingng = Integer.toBinarySsortingng(256); int length = 16 - binSsortingng.length(); char[] padArray = new char[length]; Arrays.fill(padArray, '0'); Ssortingng padSsortingng = new Ssortingng(padArray); binSsortingng = padSsortingng + binSsortingng; 

Vous pouvez utiliser Apache Commons SsortingngUtils . Il propose des méthodes pour remplir les chaînes:

 SsortingngUtils.leftPad(Integer.toBinarySsortingng(1), 16, '0'); 

Voici une nouvelle réponse pour un ancien post.

Pour insérer une valeur binary avec des zéros à une longueur spécifique, essayez ceci:

 Integer.toBinarySsortingng( (1 << len) | val ).substring( 1 ) 

Si len = 4 et val = 1 ,

 Integer.toBinarySsortingng( (1 << len) | val ) 

renvoie la chaîne "10001" , puis

 "10001".subssortingng( 1 ) 

rejette le tout premier personnage. Nous obtenons donc ce que nous voulons:

 "0001" 

Si val est susceptible d'être négatif, essayez plutôt:

 Integer.toBinarySsortingng( (1 << len) | (val & ((1 << len) - 1)) ).substring( 1 ) 

essayer…

 Ssortingng.format("%016d\n", Integer.parseInt(Integer.toBinarySsortingng(256))); 

Je ne pense pas que ce soit la façon “correcte” de faire ça … mais ça marche 🙂

Je ne connais pas la “bonne” solution mais je peux vous suggérer un patch rapide.

 Ssortingng.format("%16s", Integer.toBinarySsortingng(1)).replace(" ", "0"); 

Je viens de l’essayer et j’ai vu que cela fonctionnait bien.

Une version plus simple de l’idée de user3608934 “C’est un vieux truc, créez une chaîne de 16 0 puis ajoutez la chaîne binary tronquée que vous avez obtenue”:

 private Ssortingng toBinarySsortingng32(int i) { Ssortingng binaryWithOutLeading0 = Integer.toBinarySsortingng(i); return "00000000000000000000000000000000" .subssortingng(binaryWithOutLeading0.length()) + binaryWithOutLeading0; } 

Une solution naïve que le travail serait

 Ssortingng temp = Integer.toBinarySsortingng(5); while (temp.length() < Integer.SIZE) temp = "0"+temp; //pad leading zeros temp = temp.substring(Integer.SIZE - Short.SIZE); //remove excess 

Une autre méthode serait

 Ssortingng temp = Integer.toBinarySsortingng((m | 0x80000000)); temp = temp.subssortingng(Integer.SIZE - Short.SIZE); 

Cela produira une chaîne de 16 bits de l'entier 5

Ceci est un vieux truc, créez une chaîne de 16 0 puis ajoutez la chaîne binary découpée que vous avez obtenue de Ssortingng.format (“% s”, Integer.toBinarySsortingng (1)) et utilisez les 16 caractères les plus à droite 0 Mieux encore, créez une fonction qui vous permet de spécifier la longueur d’une chaîne binary souhaitée. Bien sûr, il y a probablement d’autres moyens d’y parvenir, y compris les bibliothèques, mais j’ajoute ce post pour aider un ami 🙂

 public class BinaryPrinter { public static void main(Ssortingng[] args) { System.out.format("%d in binary is %s\n", 1, binarySsortingng(1, 4)); System.out.format("%d in binary is %s\n", 128, binarySsortingng(128, 8)); System.out.format("%d in binary is %s\n", 256, binarySsortingng(256, 16)); } public static Ssortingng binarySsortingng( final int number, final int binaryDigits ) { final Ssortingng pattern = Ssortingng.format( "%%0%dd", binaryDigits ); final Ssortingng padding = Ssortingng.format( pattern, 0 ); final Ssortingng response = Ssortingng.format( "%s%s", padding, Integer.toBinarySsortingng(number) ); System.out.format( "\npattern = '%s'\npadding = '%s'\nresponse = '%s'\n\n", pattern, padding, response ); return response.subssortingng( response.length() - binaryDigits ); } } 

J’écrirais ma propre classe util avec la méthode comme ci-dessous

 public class NumberFormatUtils { public static Ssortingng longToBinSsortingng(long val) { char[] buffer = new char[64]; Arrays.fill(buffer, '0'); for (int i = 0; i < 64; ++i) { long mask = 1L << i; if ((val & mask) == mask) { buffer[63 - i] = '1'; } } return new String(buffer); } public static void main(String... args) { long value = 0b0000000000000000000000000000000000000000000000000000000000000101L; System.out.println(value); System.out.println(Long.toBinaryString(value)); System.out.println(NumberFormatUtils.longToBinString(value)); } 

}

Sortie:

 5
 101
 0000000000000000000000000000000000000000000000000000000000000101

La même approche pourrait être appliquée à tous les types intégraux. Faites attention au type de masque

long mask = 1L << i;

Cette méthode convertit un int en Ssortingng, length = bits. Soit rempli avec 0 ou avec les bits les plus significatifs tronqués.

 static Ssortingng toBitSsortingng( int x, int bits ){ Ssortingng bitSsortingng = Integer.toBinarySsortingng(x); int size = bitSsortingng.length(); SsortingngBuilder sb = new SsortingngBuilder( bits ); if( bits > size ){ for( int i=0; i 

Vous pouvez utiliser lib https://github.com/kssource/BitSequence . Il accepte un numéro et renvoie une chaîne bynary, remplie et / ou groupée.

 Ssortingng s = new BitSequence(2, 16).toBynarySsortingng(ALIGN.RIGHT, GROUP.CONTINOUSLY)); return 0000000000000010 another examples: [10, -20, 30]->00001010 11101100 00011110 i=-10->00000000000000000000000000001010 bi=10->1010 sh=10->00 0000 0000 1010 l=10->00000001 010 by=-10->1010 i=-10->bc->11111111 11111111 11111111 11110110 
 for(int i=0;i 

str[i].length() est la longueur du nombre disons 2 en binary est 01 qui est la longueur 2 change 4 à la longueur maximale souhaitée du nombre. Cela peut être optimisé pour O (n). en utilisant continuer.

// ci-dessous va gérer les bonnes tailles

 public static Ssortingng binarySsortingng(int i) { return Ssortingng.format("%" + Integer.SIZE + "s", Integer.toBinarySsortingng(i)).replace(' ', '0'); } public static Ssortingng binarySsortingng(long i) { return Ssortingng.format("%" + Long.SIZE + "s", Long.toBinarySsortingng(i)).replace(' ', '0'); }