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

Comment avez-vous laissé un pad intavec des zéros lors de la conversion Stringen Java?

Je cherche essentiellement à remplir les entiers 9999avec des zéros non significatifs (par exemple 1 = 0001).

Utilisez java.lang.String.format(String,Object...)comme ceci:

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

pour un remplissage nul avec une longueur de 5. Pour une sortie hexadécimale, remplacez le dpar un xcomme dans "%05x".

Les options de formatage complètes sont documentées dans le cadre de java.util.Formatter.

Disons que vous voulez imprimer 11en011

Vous pouvez utiliser un formatter : "%03d".

Vous pouvez utiliser ce formateur 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);

Si pour quelque raison que ce soit, vous utilisez Java 1.5, vous pouvez essayer avec la méthode Apache Commons Lang

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

Trouvé cet exemple ... Testera ...

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é cela et:

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

Les deux fonctionnent, pour moi, je pense que String.Format est meilleur et plus succinct.

Si les performances sont importantes dans votre cas, vous pouvez le faire vous-même avec moins de frais généraux par rapport à la String.formatfonction:

/**
 * @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

Fonction propre: 1697ms

String.format: 38134ms

Vous pouvez utiliser Google Guava :

Maven:

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

Exemple de code:

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

Remarque:

Guavaest une bibliothèque très utile, il fournit également de nombreuses fonctionnalités qui se rapportent à Collections, Caches, Functional idioms, Concurrency, Strings, Primitives, Ranges, IO, Hashing, EventBus, etc.

Réf: GuavaExplained

Essaye celui-là:

import java.text.DecimalFormat; 

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

Bien que la plupart des approches ci-dessus soient bonnes, nous devons parfois formater des entiers ainsi que des flottants. Nous pouvons l'utiliser, en particulier lorsque nous devons remplir un nombre particulier de zéros à gauche ainsi 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.

Utilisez la classe DecimalFormat, comme ceci:

NumberFormat formatter = new DecimalFormat("0000"); //i use 4 Zero but you can also another number
System.out.println("OUTPUT : "+formatter.format(811)); 

SORTIE: 0000811

Voici comment formater votre chaîne sans utiliser DecimalFormat.

String.format("%02d", 9)

09

String.format("%03d", 19)

019

String.format("%04d", 119)

0119

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

Supposons que notre premier nombre soit 2. Et nous voulons ajouter des zéros à cela pour que la longueur de la chaîne finale soit 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("\0", "0")+number;
    }        
    System.out.println(resultString);

Vous devez utiliser un formateur, le 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 oblige à mettre votre chapeau de réflexion pour comprendre comment cela fonctionne.

Aucun package requis:

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

Cela remplira la chaîne de trois caractères, et il est facile d'ajouter une partie supplémentaire pour quatre ou cinq. Je sais que ce n'est en aucun cas la solution parfaite (surtout si vous voulez une grosse corde rembourrée), mais j'aime ça.