Comment obtenir 0-collier de représentation binaire d'un entier en java?

Il n'y a pas de conversion en binaire construit en java.util.Formateur, je vous conseille d'utiliser de la Chaîne.remplacer pour remplacer les espaces par des zéros, comme dans:

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

Ou de mettre en œuvre votre propre logique de convertir des entiers en binaire de représentation avec l'ajout de padding à gauche quelque part le long des lignes données dans cette donc.
Ou si vous avez vraiment besoin de passer de nombre de format, vous pouvez convertir votre représentation binaire de BigInteger et puis le format que de zéros, mais c'est très coûteux au moment de l'exécution, comme dans:

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

J'ai essayé toutes sortes d'appels de méthode que je n'ai pas vraiment utilisé avant de faire ce travail, ils ont travaillé avec un succès modéré, jusqu'à ce que j'ai pensé à quelque chose qui est si simple qu'il pourrait peut-être marcher, et il l'a fait!

Je suis sûr que ça a été pensé avant, vous ne savez pas si c'est tout bon pour la longue chaîne de codes binaires, mais il fonctionne très bien pour 16Bit cordes. Espérons que cela aide!! (Note de la deuxième partie du code est amélioré)

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

Grâce à la Volonté de les aider à améliorer cette réponse pour le faire fonctionner avec une boucle.
Ce peut-être un peu maladroit, mais il fonctionne, merci de les améliorer et de les commenter en arrière 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;

essayer...

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

Je ne pense pas que c'est la "bonne" façon de le faire... mais ça marche 🙂

Une version plus simple de user3608934 l'idée de "C'est un vieux truc, créer une chaîne avec 16 0 puis ajouter le garni chaîne binaire vous avez ":

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

C'est un vieux truc, créer une chaîne avec 16 0 puis ajouter le garni chaîne binaire reçu de la part de la Chaîne.format("%s", Entier.toBinaryString(1)) et utilisez le bouton droit de plus de 16 caractères, tailler hors tout 0 de. Mieux encore, faire une fonction qui vous permet de spécifier combien de temps d'une chaîne binaire que vous voulez. Bien sûr, il ya probablement un bazillion d'autres manières d'y parvenir, y compris les bibliothèques, mais je suis en ajoutant 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 );
    }
}

Cette méthode convertit un entier en Chaîne de caractères de longueur=bits. Soit rembourré avec des 0 ou avec les bits les plus significatifs tronquée.

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

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 numéro de dire 2 en binaire est 01, qui est de longueur 2
changement de 4 jusqu'à la longueur maximale du numéro. Cela peut être optimisé pour O(n).
en utilisant continuer.

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