it-swarm-eu.dev

Comment obtenir une représentation binaire 0 entière d'un entier en java?

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

0000000000000001
0000000000000010
0000000010000000
0000000100000000

J'ai essayé

String.format("%16s", Integer.toBinaryString(1));

il met des espaces pour left-padding:

`               1'

Comment mettre 0s pour le remplissage. Je ne pouvais pas le trouver dans Formatter . Y a-t-il une autre façon de le faire?

Merci d'avance.

P.S. cet article décrit comment formater des entiers avec un remplissage à gauche, mais ce n'est pas le cas pour la représentation binaire.

99
khachik

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

String.format("%16s", Integer.toBinaryString(1)).replace(' ', '0')
166
Samuel Parsonage

Il n'y a pas de conversion binaire intégrée dans Java.util.Formatter. Je vous conseillerais soit d'utiliser String.replace pour remplacer le caractère d'espace par des zéros, comme dans:

String.format("%16s", Integer.toBinaryString(1)).replace(" ", "0")

Ou implémentez votre propre logique pour convertir les entiers en représentation binaire avec un bourrage à gauche ajouté quelque part dans les lignes données dans this so . Ou si vous avez vraiment besoin de passer des nombres au format, vous pouvez convertir votre représentation binaire en BigInteger. puis formatez-le avec des zéros non significatifs, mais cela coûte très cher à l'exécution, comme dans:

String.format("%016d", new BigInteger(Integer.toBinaryString(1)))
18
Zoran Regvart

Vous pouvez utiliser Apache Commons StringUtils . Il propose des méthodes pour le rembourrage des chaînes:

StringUtils.leftPad(Integer.toBinaryString(1), 16, '0');
10
Michal B

J'essayais toutes sortes d'appels de méthode que je n'avais pas vraiment utilisés auparavant pour réussir ce travail. Ils ont fonctionné avec un succès modéré, jusqu'à ce que je pense à quelque chose d'aussi simple que ça pourrait marcher, et ça a fonctionné!

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

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

Merci à Will d’avoir aidé à améliorer cette réponse pour qu’elle fonctionne avec une boucle ..__ Ceci est peut-être un peu maladroit, mais ça marche, merci de l’améliorer et de commenter si vous le pouvez ....

binString = Integer.toBinaryString(256);
int length = 16 - binString.length();
char[] padArray = new char[length];
Arrays.fill(padArray, '0');
String padString = new String(padArray);
binString = padString + binString;
8
Tom Spencer

Voici une nouvelle réponse pour un ancien post.

Pour compléter une valeur binaire avec des zéros non significatifs à une longueur spécifique, essayez ceci:

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

Si len = 4 et val = 1,

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

renvoie la chaîne "10001", puis 

"10001".substring( 1 )

élimine le tout premier caractère. Nous obtenons donc ce que nous voulons: 

"0001"

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

Integer.toBinaryString( (1 << len) | (val & ((1 << len) - 1)) ).substring( 1 )
5
Cr4paud

essayer...

String.format("%016d\n", Integer.parseInt(Integer.toBinaryString(256)));

Je ne pense pas que ce soit la "bonne" façon de faire cela ... mais ça marche :)

3
Paul

Je ne connais pas la "bonne" solution mais je peux vous proposer un correctif rapide.

String.format("%16s", Integer.toBinaryString(1)).replace(" ", "0");

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

3
AlexR

Une version plus simple de l'idée de user3608934 "C'est un vieux tour, créez une chaîne avec 16 0 puis ajoutez la chaîne binaire que vous avez obtenue":

private String toBinaryString32(int i) {
    String binaryWithOutLeading0 = Integer.toBinaryString(i);
    return "00000000000000000000000000000000"
            .substring(binaryWithOutLeading0.length())
            + binaryWithOutLeading0;
}
2
bento

Une solution naïve qui fonctionnerait

String temp = Integer.toBinaryString(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

String temp = Integer.toBinaryString((m | 0x80000000));
temp = temp.substring(Integer.SIZE - Short.SIZE);

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

1
proeng

Cette méthode convertit un int en une chaîne, longueur = bits. Rembourré avec 0 ou avec les bits les plus significatifs tronqués.

static String toBitString( int x, int bits ){
    String bitString = Integer.toBinaryString(x);
    int size = bitString.length();
    StringBuilder sb = new StringBuilder( bits );
    if( bits > size ){
        for( int i=0; i<bits-size; i++ )
            sb.append('0');
        sb.append( bitString );
    }else
        sb = sb.append( bitString.substring(size-bits, size) );

    return sb.toString();
}
0
jenfax
import Java.util.Scanner;
public class Q3{
  public static void main(String[] args) {
    Scanner scn=new Scanner(System.in);
    System.out.println("Enter a number:");
    int num=scn.nextInt();
    int numB=Integer.parseInt(Integer.toBinaryString(num));
    String strB=String.format("%08d",numB);//makes a 8 character code
    if(num>=1 && num<=255){
     System.out.println(strB);
    }else{
        System.out.println("Number should be in range between 1 and 255");
    }
  }
}
0
Devesh Kumar

Vous pouvez utiliser lib https://github.com/kssource/BitSequence . Il accepte un nombre et retourne par chaîne simple, complété et/ou groupé. 

String s = new BitSequence(2, 16).toBynaryString(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
0
Nikmass

// Ci-dessous traitera les tailles appropriées

public static String binaryString(int i) {
    return String.format("%" + Integer.SIZE + "s", Integer.toBinaryString(i)).replace(' ', '0');
}

public static String binaryString(long i) {
    return String.format("%" + Long.SIZE + "s", Long.toBinaryString(i)).replace(' ', '0');
}
0
Paul Weiss
for(int i=0;i<n;i++)
{
  for(int j=str[i].length();j<4;j++)
  str[i]="0".concat(str[i]);
}

str[i].length() est la longueur du nombre disons 2 en binaire est 01 ce qui est la longueur 2 change 4 en longueur maximale désirée du nombre. Ceci peut être optimisé à O (n) ..__ en utilisant continue.

0
Jasmeet Chhabra

Je voudrais écrire ma propre classe util avec la méthode comme ci-dessous

public class NumberFormatUtils {

public static String longToBinString(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 
 000000000000000000000000000000000000000000000000000000000010101 

La même approche pourrait être appliquée à n'importe quel type d'intégrale. Faites attention au type de masque

long mask = 1L << i;

0
Arseny Kovalchuk

Ceci est un vieux truc, créez une chaîne avec 16 0, puis ajoutez la chaîne binaire découpée obtenue de String.format ("% s", Integer.toBinaryString (1)) et utilisez les 16 caractères les plus à droite, en supprimant les 0's. Mieux encore, créez une fonction qui vous permet de spécifier la longueur d’une chaîne binaire souhaitée. Bien sûr, il existe probablement mille 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(String[] args) {
        System.out.format("%d in binary is %s\n", 1, binaryString(1, 4));
        System.out.format("%d in binary is %s\n", 128, binaryString(128, 8));
        System.out.format("%d in binary is %s\n", 256, binaryString(256, 16));
    }

    public static String binaryString( final int number, final int binaryDigits ) {
        final String pattern = String.format( "%%0%dd", binaryDigits );
        final String padding = String.format( pattern, 0 );
        final String response = String.format( "%s%s", padding, Integer.toBinaryString(number) );

        System.out.format( "\npattern = '%s'\npadding = '%s'\nresponse = '%s'\n\n", pattern, padding, response );

        return response.substring( response.length() - binaryDigits );
    }
}
0
user3608934