Empiler une chaîne de caractères Avec des zéros [dupliquer]
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 .
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
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.
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");
http://commons.apache.org/lang/api-2.3/org/apache/commons/lang/StringUtils.html
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
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
.
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();
}
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"
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: 00000101
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")
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
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");
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());
}
}
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);
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
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"));
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!