Wie formatiere ich einen Java-String mit führender Null?

Hier ist der String zum Beispiel:

"Apple"

und ich möchte Null hinzufügen, um 8 Zeichen auszufüllen:

"000Apple"

Wie kann ich das machen?

Falls Sie es ohne die Hilfe einer Bibliothek tun müssen:

("00000000" + "Apple").substring("Apple".length())

(Funktioniert, solange Ihr String nicht länger als 8 Zeichen ist.)

public class LeadingZerosExample {
    public static void main(String[] args) {
       int number = 1500;

       // String format below will add leading zeros (the %0 syntax) 
       // to the number above. 
       // The length of the formatted string will be 7 characters.

       String formatted = String.format("%07d", number);

       System.out.println("Number with leading zeros: " + formatted);
    }
}

 StringUtils.leftPad(yourString, 8, '0');

Dies ist von commons-lang . Siehe Javadoc

Darum hat er wirklich gebeten, glaube ich:

String.format("%0"+ (8 - "Apple".length() )+"d%s",0 ,"Apple"); 

Ausgabe:

000Apple

Sie können die in einer anderen Antwort verwendete String.format-Methode verwenden, um eine Zeichenfolge mit Nullen zu generieren.

String.format("%0"+length+"d",0)

Dies kann auf Ihr Problem angewendet werden, indem Sie die Anzahl der führenden Nullen in einer Formatzeichenfolge dynamisch anpassen:

public String leadingZeros(String s, int length) {
     if (s.length() >= length) return s;
     else return String.format("%0" + (length-s.length()) + "d%s", 0, s);
}

Es ist immer noch eine unübersichtliche Lösung, hat aber den Vorteil, dass Sie die Gesamtlänge der resultierenden Zeichenfolge mithilfe eines ganzzahligen Arguments angeben können.

Verwenden der StringsDienstprogrammklasse von Guava :

Strings.padStart("Apple", 8, '0');

Sie können dies verwenden:

org.apache.commons.lang.StringUtils.leftPad("Apple", 8, "0")

Ich war in einer ähnlichen Situation und habe diese genutzt. Es ist ziemlich prägnant und Sie müssen sich nicht mit der Länge oder einer anderen Bibliothek befassen.

String str = String.format("%8s","Apple");
str = str.replace(' ','0');

Einfach und ordentlich. Das Zeichenfolgenformat wird zurückgegeben, " Apple"sodass nach dem Ersetzen des Leerzeichens durch Nullen das gewünschte Ergebnis erzielt wird.

String input = "Apple";
StringBuffer buf = new StringBuffer(input);

while (buf.length() < 8) {
  buf.insert(0, '0');
}

String output = buf.toString();

Verwenden Sie Apache Commons StringUtils.leftPad (oder sehen Sie sich den Code an, um Ihre eigene Funktion zu erstellen).

public class PaddingLeft {
    public static void main(String[] args) {
        String input = "Apple";
        String result = "00000000" + input;
        int length = result.length();
        result = result.substring(length - 8, length);
        System.out.println(result);
    }
}

Möglicherweise müssen Sie sich um Edgecase kümmern. Dies ist eine generische Methode.

public class Test {
    public static void main(String[] args){
        System.out.println(padCharacter("0",8,"hello"));
    }
    public static String padCharacter(String c, int num, String str){
        for(int i=0;i<=num-str.length()+1;i++){str = c+str;}
        return str;
    }
}

public static void main(String[] args)
{
    String stringForTest = "Apple";
    int requiredLengthAfterPadding = 8;
    int inputStringLengh = stringForTest.length();
    int diff = requiredLengthAfterPadding - inputStringLengh;
    if (inputStringLengh < requiredLengthAfterPadding)
    {
        stringForTest = new String(new char[diff]).replace("\0", "0")+ stringForTest;
    }
    System.out.println(stringForTest);
}

public static String lpad(String str, int requiredLength, char padChar) {
    if (str.length() > requiredLength) {
        return str;
    } else {
        return new String(new char[requiredLength - str.length()]).replace('\0', padChar) + str;
    }
}

In Java:

String zeroes="00000000";
String apple="apple";

String result=zeroes.substring(apple.length(),zeroes.length())+apple;

In Scala:

"Apple".foldLeft("00000000"){(ac,e)=>ac.tail+e}

Sie können auch eine Möglichkeit in Java 8 untersuchen, dies mithilfe von Streams zu tun und zu reduzieren (ähnlich wie bei Scala). Es ist ein bisschen anders als alle anderen Lösungen und ich mag es besonders.

Dies ist schnell und funktioniert für jede Länge.

public static String prefixZeros(String value, int len) {
    char[] t = new char[len];
    int l = value.length();
    int k = len-l;
    for(int i=0;i<k;i++) { t[i]='0'; }
    value.getChars(0, l, t, k);
    return new String(t);
}

Kann schneller sein als Chris Lercher antwortet, wenn die meisten in String genau 8 Zeichen haben

int length = in.length();
return length == 8 ? in : ("00000000" + in).substring(length);

in meinem Fall auf meiner Maschine 1/8 schneller.

Hier ist die einfache API-freie "lesbare Skript" -Version, die ich zum Vorpolstern eines Strings verwende. (Einfach, lesbar und einstellbar).

while(str.length() < desired_length)
  str = '0'+str;

Hat jemand diese reine Java-Lösung (ohne SpringUtils) ausprobiert:

//decimal to hex string 1=> 01, 10=>0A,..
String.format("%1$2s", Integer.toString(1,16) ).replace(" ","0");
//reply to original question, string with leading zeros. 
//first generates a 10 char long string with leading spaces, and then spaces are
//replaced by a zero string. 
String.format("%1$10s", "mystring" ).replace(" ","0");

Leider funktioniert diese Lösung nur, wenn Sie keine Leerzeichen in einer Zeichenfolge haben.

Wenn Sie das Programm in reinem Java schreiben möchten, können Sie die folgende Methode anwenden, oder es gibt viele String-Utils, die Ihnen bei erweiterten Funktionen helfen.

Mit einer einfachen statischen Methode können Sie dies wie folgt erreichen.

public static String addLeadingText(int length, String pad, String value) {
    String text = value;
    for (int x = 0; x < length - value.length(); x++) text = pad + text;
    return text;
}

Sie können die obige Methode verwenden addLeadingText(length, padding text, your text)

addLeadingText(8, "0", "Apple");

Die Ausgabe wäre 000Apple

Es ist nicht schön, aber es funktioniert. Wenn Sie Zugriff auf Apache Commons haben, würde ich vorschlagen, dass Sie das verwenden

if (val.length() < 8) {
  for (int i = 0; i < val - 8; i++) {
    val = "0" + val;
  }
}