Rembourrage gauche d'une chaîne avec des zéros
Si votre chaîne ne contient que des nombres, vous pouvez en faire un entier puis effectuer un remplissage:
String.format("%010d", Integer.parseInt(mystring));
String paddedString = org.Apache.commons.lang.StringUtils.leftPad("129018", 10, "0")
le second paramètre est la longueur de sortie souhaitée
"0" est le caractère de remplissage
Ceci remplira n'importe quelle chaîne d'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 bien jouer:
String unpadded = "12345";
String padded = unpadded + "##########".substring(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 vous souhaitez définir la largeur totale de la chaîne. Par exemple. si vous souhaitez ajouter des zéros à gauche de manière à ce que la chaîne entière comprenne 15 caractères:
String unpadded = "12345";
String padded = "000000000000000".substring(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, ce qui peut générer une exception (par exemple, si le nombre que vous souhaitez tamponner est trop grand, comme 12147483647). L'inconvénient est que si ce que vous remplissez est déjà un int, vous devrez le convertir en chaîne, ce qui n'est pas souhaitable.
Donc, si vous savez avec certitude qu'il s'agit d'un int, la réponse de khatchik fonctionne très bien. Sinon, c'est une stratégie possible.
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();
String str = "129018";
String str2 = String.format("%10s", str).replace(' ', '0');
System.out.println(str2);
Vous pouvez utiliser Apache commons StringUtils
StringUtils.leftPad("129018", 10, "0");
Pour formater une chaîne, utilisez
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: 00000wrwer
Lorsque le premier argument est la chaîne à formater, le second argument correspond à la longueur de la longueur de sortie souhaitée et le troisième argument correspond au caractère avec lequel la chaîne doit être complétée.
Utilisez le lien pour télécharger le pot 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:
String zeroPad = "0000000000000000";
String str0 = zeroPad.substring(str.length()) + str;
Soyez conscient de la taille maximale de la chaîne. S'il est plus grand que la taille du StringBuffer, vous aurez un Java.lang.StringIndexOutOfBoundsException.
Utilisez Google Guava :
Maven:
<dependency>
<artifactId>guava</artifactId>
<groupId>com.google.guava</groupId>
<version>14.0.1</version>
</dependency>
Exemple de code:
Strings.padStart("129018", 10, '0') returns "0000129018"
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();
}
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());
}
}
puis:
System.out.println(StrMgr.leftPad("hello", 20, "x"));
System.out.println(StrMgr.rightPad("hello", 20, "x"));
Basé sur @ la réponse de Haroldo Macêdo , j'ai créé une méthode dans ma classe personnalisée Utils 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");
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)
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: 000101
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
Rembourrage droit avec longueur fixe-10: String.format ("% 1 $ -10s", "abc") Rembourrage gauche avec longueur fixe-10: String.format ("% 1 $ 10s", "abc")
Voici une solution basée sur String.format qui fonctionnera pour les chaînes et convient aux longueurs variables.
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'
int number = -1;
int holdingDigits = 7;
System.out.println(String.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->
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());
}
}
Vérifiez mon code qui fonctionnera pour integer et String.
Supposons que notre premier numéro est 129018. Et nous voulons ajouter des zéros afin 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("\0", "0")+number;
}
System.out.println(resultString);