Comment puis-je remplir un entier avec des zéros à gauche?

si, pour une raison quelconque, vous utilisez Pre 1.5 Java, alors vous pouvez essayer la méthode Apache Commons Lang

org.apache.commons.lang.StringUtils.leftPad(String str, int size, '0')

disons que vous voulez imprimer 11 comme 011

vous pouvez utiliser un formatteur : "%03d" .

vous pouvez utiliser ce formatteur comme ceci:

int a = 11;
String with3digits = String.format("%03d", a);
System.out.println(with3digits);

alternativement, certaines méthodes java prennent directement en charge ces formateurs:

System.out.printf("%03d", a);

a trouvé cet exemple... Permettra de tester...

import java.text.DecimalFormat;
class TestingAndQualityAssuranceDepartment
{
    public static void main(String [] args)
    {
        int x=1;
        DecimalFormat df = new DecimalFormat("00");
        System.out.println(df.format(x));
    }
}

testé et:

String.format("%05d",number);

les deux fonctionnent, pour mes besoins je pense chaîne.Le Format est meilleur et plus concis.

si la performance est importante dans votre cas, vous pouvez le faire vous-même avec moins de frais généraux par rapport à la fonction String.format :

/**
 * @param in The integer value
 * @param fill The number of digits to fill
 * @return The given value left padded with the given number of digits
 */
public static String lPadZero(int in, int fill){

    boolean negative = false;
    int value, len = 0;

    if(in >= 0){
        value = in;
    } else {
        negative = true;
        value = - in;
        in = - in;
        len ++;
    }

    if(value == 0){
        len = 1;
    } else{         
        for(; value != 0; len ++){
            value /= 10;
        }
    }

    StringBuilder sb = new StringBuilder();

    if(negative){
        sb.append('-');
    }

    for(int i = fill; i > len; i--){
        sb.append('0');
    }

    sb.append(in);

    return sb.toString();       
}

Performance

public static void main(String[] args) {
    Random rdm;
    long start; 

    // Using own function
    rdm = new Random(0);
    start = System.nanoTime();

    for(int i = 10000000; i != 0; i--){
        lPadZero(rdm.nextInt(20000) - 10000, 4);
    }
    System.out.println("Own function: " + ((System.nanoTime() - start) / 1000000) + "ms");

    // Using String.format
    rdm = new Random(0);        
    start = System.nanoTime();

    for(int i = 10000000; i != 0; i--){
        String.format("%04d", rdm.nextInt(20000) - 10000);
    }
    System.out.println("String.format: " + ((System.nanoTime() - start) / 1000000) + "ms");
}

résultat

propre fonction: 1697ms

de la Chaîne.format: 38134ms

Vous pouvez utiliser Google Goyave :

Maven:

<dependency>
     <artifactId>guava</artifactId>
     <groupId>com.google.guava</groupId>
     <version>14.0.1</version>
</dependency>

code échantillon:

String paddedString1 = Strings.padStart("7", 3, '0'); //"007"
String paddedString2 = Strings.padStart("2020", 3, '0'); //"2020"

Note:

Guava est une bibliothèque très utile, il fournit également beaucoup de fonctionnalités qui ont trait à Collections , Caches , Functional idioms , Concurrency , Strings , Primitives , Ranges , IO , Hashing , EventBus , etc

Réf: GuavaExplained

bien que beaucoup des approches ci-dessus sont bonnes, mais parfois nous avons besoin de formater des entiers aussi bien que des flotteurs. Nous pouvons utiliser cela, en particulier quand nous avons besoin de garnir le nombre particulier de zéros à gauche aussi bien qu'à droite des nombres décimaux.

import java.text.NumberFormat;  
public class NumberFormatMain {  

public static void main(String[] args) {  
    int intNumber = 25;  
    float floatNumber = 25.546f;  
    NumberFormat format=NumberFormat.getInstance();  
    format.setMaximumIntegerDigits(6);  
    format.setMaximumFractionDigits(6);  
    format.setMinimumFractionDigits(6);  
    format.setMinimumIntegerDigits(6);  

    System.out.println("Formatted Integer : "+format.format(intNumber).replace(",",""));  
    System.out.println("Formatted Float   : "+format.format(floatNumber).replace(",",""));  
 }    
}  

int x = 1;
System.out.format("%05d",x);

si vous souhaitez imprimer le texte formaté directement sur l'écran.

essayez celui-ci:

DecimalFormat df = new DecimalFormat("0000");
String c = df.format(9);   // 0009
String a = df.format(99);  // 0099
String b = df.format(999); // 0999

Vérifiez mon code qui fonctionnera pour entier et chaîne.

supposons que notre premier chiffre est 2. Et nous voulons ajouter des zéros pour que la longueur de la chaîne finale soit de 4. Pour cela vous pouvez utiliser le code suivant

    int number=2;
    int requiredLengthAfterPadding=4;
    String resultString=Integer.toString(number);
    int inputStringLengh=resultString.length();
    int diff=requiredLengthAfterPadding-inputStringLengh;
    if(inputStringLengh<requiredLengthAfterPadding)
    {
        resultString=new String(new char[diff]).replace(""151900920"", "0")+number;
    }        
    System.out.println(resultString);

vous devez utiliser un Formatteur, code suivant utilise NumberFormat

    int inputNo = 1;
    NumberFormat nf = NumberFormat.getInstance();
    nf.setMaximumIntegerDigits(4);
    nf.setMinimumIntegerDigits(4);
    nf.setGroupingUsed(false);

    System.out.println("Formatted Integer : " + nf.format(inputNo));

sortie: 0001

public static String zeroPad(long number, int width) {
   long wrapAt = (long)Math.pow(10, width);
   return String.valueOf(number % wrapAt + wrapAt).substring(1);
}

le seul problème avec cette approche est qu'elle vous fait enfiler votre chapeau de penseur pour comprendre comment cela fonctionne.

pas de colis nécessaires:

String paddedString = i < 100 ? i < 10 ? "00" + i : "0" + i : "" + i;

cela va coller la chaîne de caractères à trois caractères, et il est facile d'ajouter une partie de plus pour quatre ou cinq. Je sais que ce n'est pas la solution idéale, en quelque sorte (surtout si vous voulez un grand collier de chaîne), mais je l'aime.