Java dizesini başında sıfır ile nasıl biçimlendiririm?

İşte Dize, örneğin:

"Apple"

ve 8 karakter doldurmak için sıfır eklemek istiyorum:

"000Apple"

Bunu nasıl yapabilirim?

Bunu bir kütüphane yardımı olmadan yapmanız gerektiğinde:

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

(Dizeniz 8 karakterden uzun olmadığı sürece çalışır.)

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

Bu commons-lang'den . Bkz. Javadoc

Ben gerçekten bunu istediğine inanıyorum:

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

çıktı:

000Apple

0'lı bir dize oluşturmak için başka bir yanıtta kullanılan String.format yöntemini kullanabilirsiniz,

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

Bu, bir biçim dizesindeki önde gelen 0 sayısını dinamik olarak ayarlayarak sorununuza uygulanabilir:

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

Hala dağınık bir çözümdür, ancak bir tamsayı argümanı kullanarak sonuçlanan dizenin toplam uzunluğunu belirtebilme avantajına sahiptir.

Guava'nın Stringsyardımcı sınıfını kullanarak :

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

Bunu kullanabilirsiniz:

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

Benzer bir durumdaydım ve bunu kullandım; Oldukça özlü ve uzunluk veya başka bir kütüphane ile uğraşmak zorunda değilsiniz.

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

Basit ve temiz. Dize biçimi, " Apple"alanı sıfırlarla değiştirdikten sonra istenen sonucu verir.

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

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

String output = buf.toString();

Apache Commons StringUtils.leftPad kullanın (veya kendi işlevinizi yapmak için koda bakın).

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

Edgecase ile ilgilenmeniz gerekebilir. Bu genel bir yöntemdir.

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

Java dilinde:

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

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

Scala'da:

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

Ayrıca Java 8'de akışları kullanarak bunu yapmanın bir yolunu keşfedebilir ve azaltabilirsiniz (Scala ile yaptığım gibi). Diğer tüm çözümlerden biraz farklı ve özellikle çok beğendim.

Bu hızlıdır ve her uzunlukta çalışır.

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

String'deki çoğu tam olarak 8 karaktere sahip olduğunda Chris Lercher'ın cevabından daha hızlı olabilir

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

benim durumumda 1/8 daha hızlı.

İşte bir dize ön doldurma için kullandığım basit API'sız "okunabilir komut dosyası" sürümü. (Basit, Okunabilir ve Ayarlanabilir).

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

Herkes bu saf Java çözümünü denedi mi (SpringUtils olmadan):

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

Ne yazık ki bu çözüm yalnızca bir dizede boş alan yoksa çalışır.

Programı saf Java'da yazmak istiyorsanız, aşağıdaki yöntemi takip edebilirsiniz veya daha gelişmiş özelliklerle daha iyi yardımcı olmak için birçok String Utils vardır.

Basit bir statik yöntem kullanarak bunu aşağıdaki gibi yapabilirsiniz.

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

Yukarıdaki yöntemi kullanabilirsiniz addLeadingText(length, padding text, your text)

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

Çıktı 000Apple olur

Güzel değil, ama işe yarıyor. Eğer erişim apache commons varsa ben bunu kullanmanızı öneririz

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