Empiler une chaîne de caractères Avec des zéros [dupliquer]

cette question a déjà une réponse ici:

j'ai vu des questions similaires ici et ici .

mais je ne sais pas comment mettre à gauche une corde avec zéro.

entrée: "129018" sortie: "0000129018 "

la longueur totale de sortie devrait être de dix.

203
demandé sur Community 2010-12-17 13:45:33

20 réponses

si votre chaîne ne contient que des nombres, vous pouvez en faire un entier et ensuite faire du remplissage:

String.format("%010d", Integer.parseInt(mystring));

si ce n'est pas j'aimerais savoir comment faire .

300
répondu khachik 2017-05-23 12:34:47
String paddedString = org.apache.commons.lang.StringUtils.leftPad("129018", 10, "0")

le second paramètre est la longueur de sortie désirée

"0" est le rembourrage char

127
répondu Oliver Michels 2018-05-21 13:03:07

cela va pad laissé n'importe quelle corde à une largeur totale de 10 sans se soucier des erreurs d'analyse:

String unpadded = "12345"; 
String padded = "##########".substring(unpadded.length()) + unpadded;

//unpadded is "12345"
//padded   is "#####12345"

si vous voulez tourner à droite:

String unpadded = "12345"; 
String padded = unpadded + "##########".substring(unpadded.length());

//unpadded is "12345"
//padded   is "12345#####"  

Vous pouvez remplacer les caractères "#" avec le caractère que vous voulez pad, a répété le nombre de fois que vous voulez la largeur totale de la chaîne. Par exemple: si vous voulez ajouter des zéros à gauche pour que la chaîne entière soit longue de 15 caractères:

String unpadded = "12345"; 
String padded = "000000000000000".substring(unpadded.length()) + unpadded;

//unpadded is "12345"
//padded   is "000000000012345"  

L'avantage de ce khachik la réponse est qu'il n'utilise pas Entier.parseInt, qui peut lancer une Exception (par exemple, si le nombre que vous voulez pad est trop grand comme 12147483647). L'inconvénient est que si ce que vous padding est déjà un int, alors vous devrez le convertir en une chaîne et retour, ce qui est indésirable.

donc, si vous êtes sûr que c'est un int, la réponse de khachik fonctionne bien. Si non, alors c'est possible de la stratégie.

92
répondu Rick Hanlon II 2018-03-29 12:40:13
String str = "129018";
StringBuilder sb = new StringBuilder();

for (int toPrepend=10-str.length(); toPrepend>0; toPrepend--) {
    sb.append('0');
}

sb.append(str);
String result = sb.toString();
47
répondu thejh 2013-03-03 11:40:16
String str = "129018";
String str2 = String.format("%10s", str).replace(' ', '0');
System.out.println(str2);
41
répondu Satish 2011-05-25 20:29:51

vous pouvez utiliser apache commons StringUtils

StringUtils.leftPad("129018", 10, "0");

http://commons.apache.org/lang/api-2.3/org/apache/commons/lang/StringUtils.html

13
répondu thk 2011-08-15 11:00:17

pour formater la chaîne utiliser

import org.apache.commons.lang.StringUtils;

public class test {

    public static void main(String[] args) {

        String result = StringUtils.leftPad("wrwer", 10, "0");
        System.out.println("The String : " + result);

    }
}

sortie : la chaîne de caractères: 00000wrwer

où le premier argument est la chaîne à formater, le deuxième argument est la longueur de la longueur de sortie désirée et le troisième argument est le caractère avec lequel la chaîne doit être capitonnée.

utilisez le lien pour télécharger le jar http://commons.apache.org/proper/commons-lang/download_lang.cgi

13
répondu Nagarajan S R 2017-07-10 15:09:19

si vous avez besoin de performances et de connaître la taille maximale de la chaîne, utilisez ceci:

String zeroPad = "0000000000000000";
String str0 = zeroPad.substring(str.length()) + str;

Être conscient de la taille maximale de la chaîne. S'il est plus grand que la taille de la pince, vous obtiendrez un java.lang.StringIndexOutOfBoundsException .

10
répondu Haroldo Macedo 2017-03-23 10:29:40

une vieille question, mais j'ai aussi deux méthodes.


pour une longueur fixe (prédéfinie):

    public static String fill(String text) {
        if (text.length() >= 10)
            return text;
        else
            return "0000000000".substring(text.length()) + text;
    }

pour une longueur variable:

    public static String fill(String text, int size) {
        StringBuilder builder = new StringBuilder(text);
        while (builder.length() < size) {
            builder.append('0');
        }
        return builder.toString();
    }
4
répondu Carlos Heuberger 2011-05-25 21:05:41

Utiliser Google Goyave :

Maven:

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

code échantillon:

Strings.padStart("129018", 10, '0') returns "0000129018"  
4
répondu ThoQ 2016-02-10 12:29:24

Voici une autre approche:

int pad = 4;
char[] temp = (new String(new char[pad]) + "129018").toCharArray()
Arrays.fill(temp, 0, pad, '0');
System.out.println(temp)
2
répondu nullpotent 2013-08-19 17:38:55

voici ma solution:

String s = Integer.toBinaryString(5); //Convert decimal to binary
int p = 8; //preferred length
for(int g=0,j=s.length();g<p-j;g++, s= "0" + s);
System.out.println(s);

sortie: 00000101

2
répondu Sherwin Pitao 2016-08-24 07:30:48

rembourrage droit avec longueur fixe-10: Chaîne.format ("%1$-10s", " abc") Rembourrage à gauche avec la longueur fixe-10: Chaîne.format ("%1$10s"," abc")

1
répondu Arun 2014-11-20 23:22:44

la solution de Satish est très bonne parmi les réponses attendues. Je voulais le rendre plus général en ajoutant la variable n à la chaîne de format au lieu de 10 caractères.

int maxDigits = 10;
String str = "129018";
String formatString = "%"+n+"s";
String str2 = String.format(formatString, str).replace(' ', '0');
System.out.println(str2);

cela fonctionnera dans la plupart des situations

1
répondu Prabhu 2016-03-02 04:30:28

basé sur la réponse de @Haroldo Macêdo , j'ai créé une méthode dans ma coutume Utils classe telle que

/**
 * Left padding a string with the given character
 *
 * @param str     The string to be padded
 * @param length  The total fix length of the string
 * @param padChar The pad character
 * @return The padded string
 */
public static String padLeft(String str, int length, String padChar) {
    String pad = "";
    for (int i = 0; i < length; i++) {
        pad += padChar;
    }
    return pad.substring(str.length()) + str;
}

puis appelez Utils.padLeft(str, 10, "0");

1
répondu Sithu 2017-05-23 12:26:37
    int number = -1;
    int holdingDigits = 7;
    System.out.println(String.format("%0"+ holdingDigits +"d", number));

vient de le demander dans une interview........

Ma réponse ci-dessous, mais ce (mentionné ci-dessus) est beaucoup plus agréable->

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

ma réponse est:

static String leadingZeros(int num, int digitSize) {
    //test for capacity being too small.

    if (digitSize < String.valueOf(num).length()) {
        return "Error : you number  " + num + " is higher than the decimal system specified capacity of " + digitSize + " zeros.";

        //test for capacity will exactly hold the number.
    } else if (digitSize == String.valueOf(num).length()) {
        return String.valueOf(num);

        //else do something here to calculate if the digitSize will over flow the StringBuilder buffer java.lang.OutOfMemoryError 

        //else calculate and return string
    } else {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < digitSize; i++) {
            sb.append("0");
        }
        sb.append(String.valueOf(num));
        return sb.substring(sb.length() - digitSize, sb.length());
    }
}
0
répondu bockymurphy 2013-04-26 14:50:17

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

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

    int number=129018;
    int requiredLengthAfterPadding=10;
    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);
0
répondu Fathah Rehman P 2014-07-24 10:31:15

Voici une solution basée sur une chaîne de caractères.format qui fonctionnera pour les chaînes et qui convient à la longueur variable.

public static String PadLeft(String stringToPad, int padToLength){
    String retValue = null;
    if(stringToPad.length() < padToLength) {
        retValue = String.format("%0" + String.valueOf(padToLength - stringToPad.length()) + "d%s",0,stringToPad);
    }
    else{
        retValue = stringToPad;
    }
    return retValue;
}

public static void main(String[] args) {
    System.out.println("'" + PadLeft("test", 10) + "'");
    System.out.println("'" + PadLeft("test", 3) + "'");
    System.out.println("'" + PadLeft("test", 4) + "'");
    System.out.println("'" + PadLeft("test", 5) + "'");
}

sortie: "000000test" "test" "test" "0test

0
répondu P.V.M. Kessels 2015-07-29 07:25:09

je préfère ce code:

public final class StrMgr {

    public static String rightPad(String input, int length, String fill){                   
        String pad = input.trim() + String.format("%"+length+"s", "").replace(" ", fill);
        return pad.substring(0, length);              
    }       

    public static String leftPad(String input, int length, String fill){            
        String pad = String.format("%"+length+"s", "").replace(" ", fill) + input.trim();
        return pad.substring(pad.length() - length, pad.length());
    }
}

et ensuite:

System.out.println(StrMgr.leftPad("hello", 20, "x")); 
System.out.println(StrMgr.rightPad("hello", 20, "x"));
0
répondu Ariel Giomi 2017-02-15 01:42:46

j'ai utilisé ceci:

DecimalFormat numFormat = new DecimalFormat("00000");
System.out.println("Code format: "+numFormat.format(123));

résultat: 00123

j'espère que vous le trouverez utile!

-1
répondu Carlos Muñoz 2017-02-15 02:30:20