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

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 aus commons-lang . Siehe Javadoc

Das ist es, worum er wirklich gebeten hat, glaube ich:

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

ausgabe:

000Apple

Sie können die Methode String.format wie in einer anderen Antwort verwendet, um eine Zeichenfolge von 0 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 unordentliche Lösung, hat aber den Vorteil, dass Sie die Gesamtlänge der resultierenden Zeichenfolge mit einem Integer-Argument angeben können.

Verwenden der Guavas Strings utility-Klasse:

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 dies genutzt; Es ist ziemlich knapp und Sie müssen sich nicht mit Länge oder einer anderen Bibliothek beschäftigen.

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

Einfach und ordentlich. Das String-Format gibt " Apple" zurück. Nach dem Ersetzen von Leerzeichen durch Nullen ergibt sich das gewünschte Ergebnis.

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

Möglicherweise müssen Sie sich um das 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 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);
    }
}

Hier ist die einfache API-lose "lesbare Skript" -Version, die ich zum Vorauffüllen einer Zeichenfolge verwende. (Einfach, lesbar und einstellbar).

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

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.

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

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 in einer Zeichenfolge keine Leerzeichen enthalten sind. 

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 einen Weg in Java 8 erkunden, um 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.