¿Cómo formatear una cadena Java con cero a la izquierda?

Aquí está la cadena, por ejemplo:

"Apple"

y me gustaría agregar cero para completar 8 caracteres:

"000Apple"

¿Como lo puedo hacer?

En caso de que tenga que hacerlo sin la ayuda de una biblioteca:

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

(Funciona, siempre que su Cadena no sea más larga que 8 caracteres).

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

Esto es de commons-lang . Ver javadoc

Esto es lo que realmente estaba pidiendo, creo:

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

salida:

000Apple

Puede usar el método String.format como se usa en otra respuesta para generar una cadena de 0,

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

Esto se puede aplicar a su problema ajustando dinámicamente el número de ceros a la izquierda en una cadena de formato:

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

Sigue siendo una solución desordenada, pero tiene la ventaja de que puede especificar la longitud total de la cadena resultante utilizando un argumento entero.

Usando la Stringsclase de utilidad de Guava :

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

Puedes usar esto:

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

He estado en una situación similar y usé esto; Es bastante conciso y no tiene que lidiar con la longitud u otra biblioteca.

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

Simple y ordenado. El formato de cadena vuelve " Apple"así que después de reemplazar el espacio con ceros, da el resultado deseado.

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

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

String output = buf.toString();

Use Apache Commons StringUtils.leftPad (o mire el código para hacer su propia funció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);
    }
}

Puede que tenga que cuidar edgecase. Este es un método genérico.

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

En Java:

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

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

En Scala:

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

También puede explorar una forma en Java 8 para hacerlo usando secuencias y reducir (similar a como lo hice con Scala). Es un poco diferente a todas las otras soluciones y particularmente me gusta mucho.

Esto es rápido y funciona para cualquier longitud.

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

Puede ser más rápido que la respuesta de Chris Lercher cuando la mayor parte de String tiene exactamente 8 caracteres

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

en mi caso en mi máquina 1/8 más rápido.

Aquí está la versión simple de "script legible" sin API que uso para rellenar previamente una cadena. (Simple, legible y ajustable).

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

¿Alguien intentó esta solución pura de Java (sin SpringUtils):

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

Desafortunadamente, esta solución solo funciona si no tiene espacios en blanco en una cadena.

Si desea escribir el programa en Java puro, puede seguir el siguiente método o hay muchas Utilidades de cadena para ayudarlo mejor con características más avanzadas.

Usando un método estático simple, puede lograr esto de la siguiente manera.

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

Puedes usar el método anterior addLeadingText(length, padding text, your text)

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

La salida sería 000Apple

No es bonito, pero funciona. Si tiene acceso a apache commons, le sugiero que use ese

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