Linke Auffüllung eines Strings mit Nullen

Ich habe ähnliche und ähnliche Fragen hier und hier gesehen .

Aber ich bekomme nicht, wie man einen String mit Zero packt.

Eingabe: “129018” Ausgabe: “0000129018”

Die Gesamtausgabelänge sollte TEN betragen.

Solutions Collecting From Web of "Linke Auffüllung eines Strings mit Nullen"

Wenn Ihre Zeichenfolge nur Zahlen enthält, können Sie sie zu einer Ganzzahl machen und dann padding:

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

Wenn nicht, würde ich gerne wissen, wie es geht .

 String paddedString = org.apache.commons.lang.StringUtils.leftPad("129018", 10, "0") 

Der zweite Parameter ist die gewünschte Ausgabelänge

“0” ist das Füllzeichen

Dadurch wird eine beliebige Zeichenfolge auf eine Gesamtbreite von 10 zurückgesetzt, ohne dass Sie sich um Syntaxerrors kümmern müssen:

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

Wenn Sie richtig padieren wollen:

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

Sie können die “#” – Zeichen durch ein beliebiges Zeichen ersetzen, das Sie auffüllen möchten, indem Sie die Häufigkeit wiederholen, mit der die Gesamtbreite der Zeichenfolge festgelegt werden soll. Wenn Sie z. B. Nullen nach links hinzufügen möchten, so dass die ganze Zeichenfolge 15 Zeichen lang ist:

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

Der Vorteil gegenüber khachiks Antwort ist, dass Integer.parseInt nicht verwendet wird, was eine Exception auslösen kann (zB wenn die Zahl, die Sie auffüllen möchten, zu groß ist wie 12147483647). Der Nachteil ist, dass, wenn das, was Sie auffüllen, bereits ein int ist, dann müssen Sie es in einen String und zurück konvertieren, was unerwünscht ist.

Also, wenn Sie sicher wissen, dass es ein Int ist, funktioniert die Antwort von Khachik großartig. Wenn nicht, dann ist dies eine mögliche Strategie.

 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); 

Sie können Apache commons StringUtils verwenden

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

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

Formatieren der Zeichenfolge verwenden

 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); } } 

Ausgabe: Die Zeichenfolge: 00000wrwer

Wenn das erste Argument die zu formatierende Zeichenfolge ist, ist das zweite Argument die Länge der gewünschten Ausgabelänge und das dritte Argument ist das Zeichen, mit dem die Zeichenfolge aufgefüllt werden soll.

Verwenden Sie den Link, um das Jar http://commons.apache.org/proper/commons-lang/download_lang.cgi herunterzuladen

Wenn Sie performance benötigen und die maximale Größe der Zeichenfolge kennen, verwenden Sie Folgendes:

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

Beachten Sie die maximale Stringgröße. Wenn es größer als die StringBuffer-Größe ist, erhalten Sie eine java.lang.StringIndexOutOfBoundsException .

Eine alte Frage, aber ich habe auch zwei Methoden.


Für eine feste (vordefinierte) Länge:

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

Für eine variable Länge:

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

Verwenden Sie Google Guava :

Maven:

  guava com.google.guava 14.0.1  

Beispielcode:

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

Hier ist ein anderer Ansatz:

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

Hier ist meine Lösung:

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

Ausgabe: 00000101

Rechtes Padding mit fix length-10: String.format (“% 1 $ -10s”, “abc”) Left padding mit fix length-10: String.format (“% 1 $ 10s”, “abc”)

Die Lösung von Satish ist sehr gut unter den erwarteten Antworten. Ich wollte es allgemeiner machen, indem ich die Variable n statt 10 Zeichen zur Formatzeichenfolge hinzufüge.

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

Dies funktioniert in den meisten Situationen

Basierend auf der Antwort von @Haroldo Macêdo habe ich eine Methode in meiner benutzerdefinierten Utils class wie z

 /** * 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; } 

Rufen Utils.padLeft(str, 10, "0"); dann Utils.padLeft(str, 10, "0");

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

Ich habe das nur in einem Interview gefragt …

Meine Antwort unten, aber das (oben erwähnt) ist viel schöner->

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

Meine Antwort ist:

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

Überprüfen Sie meinen Code, der für Integer und String funktioniert.

Angenommen, unsere erste Zahl ist 129018. Und wir wollen Nullen hinzufügen, damit die Länge der letzten Zeichenfolge 10 beträgt. Dafür können Sie den folgenden Code verwenden

  int number=129018; int requiredLengthAfterPadding=10; String resultString=Integer.toString(number); int inputStringLengh=resultString.length(); int diff=requiredLengthAfterPadding-inputStringLengh; if(inputStringLengh 

Hier ist eine Lösung basierend auf String.format, die für Strings funktioniert und für variable Länge geeignet ist.

 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) + "'"); } 

Ausgabe: '000000test' 'test' 'test' '0test'

Ich bevorzuge diesen 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()); } } 

und dann:

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

Ich habe das benutzt:

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

Ergebnis: 00123

Ich hoffe, Sie finden es nützlich!