Rembourrage gauche d’une chaîne avec des zéros

J’ai vu des questions similaires ici et ici .

Mais je ne comprends pas comment laisser une chaîne avec Zero.

entrée: “129018” sortie: “0000129018”

La longueur totale de sortie doit être TEN.

Si votre chaîne ne contient que des nombres, vous pouvez en faire un entier, puis faire un remplissage:

 Ssortingng.format("%010d", Integer.parseInt(myssortingng)); 

Sinon, je voudrais savoir comment cela peut être fait .

 Ssortingng paddedSsortingng = org.apache.commons.lang.SsortingngUtils.leftPad("129018", 10, "0") 

le deuxième paramètre est la longueur de sortie souhaitée

“0” est le caractère de remplissage

Cela laissera n’importe quelle chaîne à une largeur totale de 10 sans se soucier des erreurs d’parsing:

 Ssortingng unpadded = "12345"; Ssortingng padded = "##########".subssortingng(unpadded.length()) + unpadded; //unpadded is "12345" //padded is "#####12345" 

Si vous voulez compléter correctement:

 Ssortingng unpadded = "12345"; Ssortingng padded = unpadded + "##########".subssortingng(unpadded.length()); //unpadded is "12345" //padded is "12345#####" 

Vous pouvez remplacer les caractères “#” par le caractère que vous souhaitez utiliser, en répétant le nombre de fois que la largeur totale de la chaîne doit être. Par exemple, si vous souhaitez append des zéros à gauche pour que la chaîne entière ait 15 caractères:

 Ssortingng unpadded = "12345"; Ssortingng padded = "000000000000000".subssortingng(unpadded.length()) + unpadded; //unpadded is "12345" //padded is "000000000012345" 

L’avantage de cette réponse par rapport à khachik est que cela n’utilise pas Integer.parseInt, qui peut déclencher une exception (par exemple, si le numéro que vous voulez append est trop grand, comme 12147483647). L’inconvénient est que si ce que vous rembourrez est déjà un int, vous devrez le convertir en Ssortingng et inversement, ce qui n’est pas souhaitable.

Donc, si vous savez que c’est un int, la réponse de khachik fonctionne très bien. Si non, alors c’est une stratégie possible.

 Ssortingng str = "129018"; SsortingngBuilder sb = new SsortingngBuilder(); for (int toPrepend=10-str.length(); toPrepend>0; toPrepend--) { sb.append('0'); } sb.append(str); Ssortingng result = sb.toSsortingng(); 
 Ssortingng str = "129018"; Ssortingng str2 = Ssortingng.format("%10s", str).replace(' ', '0'); System.out.println(str2); 

Vous pouvez utiliser des apache commons SsortingngUtils

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

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

Pour formater l’utilisation des chaînes

 import org.apache.commons.lang.SsortingngUtils; public class test { public static void main(Ssortingng[] args) { Ssortingng result = SsortingngUtils.leftPad("wrwer", 10, "0"); System.out.println("The Ssortingng : " + result); } } 

Sortie: la chaîne: 00000wrwer

Lorsque le premier argument est la chaîne à formater, le second argument est la longueur de la longueur de sortie souhaitée et le troisième argument est le caractère avec lequel la chaîne doit être remplie.

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

Si vous avez besoin de performances et que vous connaissez la taille maximale de la chaîne, utilisez ceci:

 Ssortingng zeroPad = "0000000000000000"; Ssortingng str0 = zeroPad.subssortingng(str.length()) + str; 

Soyez conscient de la taille maximale de la chaîne. Si elle est plus grande que la taille de SsortingngBuffer, vous obtiendrez une java.lang.SsortingngIndexOutOfBoundsException .

Une vieille question, mais j’ai aussi deux méthodes.


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

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

Pour une longueur variable:

  public static Ssortingng fill(Ssortingng text, int size) { SsortingngBuilder builder = new SsortingngBuilder(text); while (builder.length() < size) { builder.append('0'); } return builder.toString(); } 

Utilisez Google Goyave :

Maven:

  guava com.google.guava 14.0.1  

Exemple de code:

 Ssortingngs.padStart("129018", 10, '0') returns "0000129018" 

Voici une autre approche:

 int pad = 4; char[] temp = (new Ssortingng(new char[pad]) + "129018").toCharArray() Arrays.fill(temp, 0, pad, '0'); System.out.println(temp) 

Voici ma solution:

 Ssortingng s = Integer.toBinarySsortingng(5); //Convert decimal to binary int p = 8; //preferred length for(int g=0,j=s.length();g 

Sortie: 00000101

Remplissage à droite avec la longueur de correction-10: Ssortingng.format (“% 1 $ -10s”, “abc”) Remplissage à gauche avec la longueur de correction-10: Ssortingng.format (“% 1 $ 10s”, “abc”)

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 au format chaîne au lieu de 10 caractères.

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

Cela fonctionnera dans la plupart des situations

Sur la base de la réponse de @Haroldo Macêdo , j’ai créé une méthode dans ma classe Utils personnalisée, telle que

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

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

  int number = -1; int holdingDigits = 7; System.out.println(Ssortingng.format("%0"+ holdingDigits +"d", number)); 

Juste demandé cela dans une interview ……..

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

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

Ma réponse est:

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

Vérifiez mon code qui fonctionnera pour les nombres entiers et les chaînes.

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

  int number=129018; int requiredLengthAfterPadding=10; Ssortingng resultSsortingng=Integer.toSsortingng(number); int inputSsortingngLengh=resultSsortingng.length(); int diff=requiredLengthAfterPadding-inputSsortingngLengh; if(inputSsortingngLengh 

Voici une solution basée sur Ssortingng.format qui fonctionnera pour les chaînes et convient à la longueur variable.

 public static Ssortingng PadLeft(Ssortingng ssortingngToPad, int padToLength){ Ssortingng retValue = null; if(ssortingngToPad.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'

Je préfère ce code:

 public final class StrMgr { public static Ssortingng rightPad(Ssortingng input, int length, Ssortingng fill){ Ssortingng pad = input.sortingm() + Ssortingng.format("%"+length+"s", "").replace(" ", fill); return pad.subssortingng(0, length); } public static Ssortingng leftPad(Ssortingng input, int length, Ssortingng fill){ Ssortingng pad = Ssortingng.format("%"+length+"s", "").replace(" ", fill) + input.sortingm(); return pad.subssortingng(pad.length() - length, pad.length()); } } 

et alors:

 System.out.println(StrMgr.leftPad("hello", 20, "x")); System.out.println(StrMgr.rightPad("hello", 20, "x")); 

J’ai utilisé ceci:

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

Résultat: 00123

J’espère que tu trouves cela utile!