java - settitle - Relleno izquierdo de una cadena con ceros

para que sirve settitle en java

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo puedo rellenar una cadena en Java? 26 respuestas

He visto preguntas similares here y here .

Pero no estoy aprendiendo a usar el teclado izquierdo String con Zero.

entrada: "129018" salida: "0000129018"

La longitud de salida total debe ser DIEZ.

Answer 1

Aquí está mi solución:

String s = Integer.toBinaryString(5); //Convert decimal to binary
int p = 8; //preferred length
for(int g=0,j=s.length();g<p-j;g++, s= "0" + s);
System.out.println(s);

Salida: 00000101

Answer 2

Aquí hay otro enfoque:

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

Answer 3

Aquí hay una solución basada en String.format que funcionará para cadenas y es adecuada para longitud variable.

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

Salida: ''000000test'' ''prueba'' ''prueba'' ''0test''

Answer 4

Basado en la respuesta de @Haroldo Macêdo , creé un método en mi clase de Utils personalizada, como

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

Luego llame a Utils.padLeft(str, 10, "0");

Answer 5

Comprueba mi código que funcione para enteros y cadenas.

Supongamos que nuestro primer número es 129018. Y queremos agregar ceros a eso, por lo que la longitud de la cadena final será 10. Para eso, puede usar el siguiente código

    int number=129018;
    int requiredLengthAfterPadding=10;
    String resultString=Integer.toString(number);
    int inputStringLengh=resultString.length();
    int diff=requiredLengthAfterPadding-inputStringLengh;
    if(inputStringLengh<requiredLengthAfterPadding)
    {
        resultString=new String(new char[diff]).replace("/0", "0")+number;
    }        
    System.out.println(resultString);

Answer 6

Esto dejará cualquier cadena a un ancho total de 10 sin preocuparse por los errores de análisis:

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

//unpadded is "12345"
//padded   is "#####12345"

Si quieres rellenar a la derecha:

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

//unpadded is "12345"
//padded   is "12345#####"  

Puedes reemplazar los caracteres "#" con cualquier carácter con el que te gustaría rellenar, repite la cantidad de veces que quieras que sea el ancho total de la cadena. Por ejemplo, si desea agregar ceros a la izquierda para que toda la cadena tenga 15 caracteres:

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

//unpadded is "12345"
//padded   is "000000000012345"  

La ventaja de esto sobre la respuesta de khachik es que no usa Integer.parseInt, que puede lanzar una Excepción (por ejemplo, si el número que desea rellenar es demasiado grande como 12147483647). La desventaja es que si lo que está rellenando ya es un int, entonces tendrá que convertirlo en un String y viceversa, lo que no es deseable.

Entonces, si está seguro de que es un int, la respuesta de khachik funciona muy bien. Si no, entonces esta es una estrategia posible.

Answer 7

He usado esto:

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

Resultado: 00123

¡Espero que les sea útil!

Answer 8

La solución de Satish es muy buena entre las respuestas esperadas. Quería hacerlo más general agregando la variable n al formato de cadena en lugar de 10 caracteres.

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

Esto funcionará en la mayoría de las situaciones

Answer 9

Para formatear el uso de la cadena

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

    }
}

Salida: La Cadena: 00000wrwer

Cuando el primer argumento es la cadena a formatear, el segundo argumento es la longitud de la longitud de salida deseada y el tercer argumento es el carácter con el que se debe rellenar la cadena.

Utilice el enlace para descargar el archivo http://commons.apache.org/proper/commons-lang/download_lang.cgi

Answer 10

Prefiero este código:

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

y entonces:

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

Answer 11

Relleno derecho con arreglo de longitud-10: String.format ("% 1 $ -10s", "abc")

Answer 12

Si necesita rendimiento y sabe el tamaño máximo de la cadena, use esto:

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

Tenga en cuenta el tamaño máximo de la cadena. Si es más grande que el tamaño StringBuffer, obtendrás una java.lang.StringIndexOutOfBoundsException .

Answer 13

Si su cadena solo contiene números, puede convertirla en un número entero y luego rellenar:

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

Si no, me gustaría saber cómo se puede hacer .

Answer 14

Una vieja pregunta, pero también tengo dos métodos.

Para una longitud fija (predefinida):

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

Para una longitud variable:

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

Answer 15

Usted puede usar StringUtils de apache commons

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

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

Answer 16

Utilice Google Guava :

Maven

<dependency>
     <artifactId>guava</artifactId>
     <groupId>com.google.guava</groupId>
     <version>14.0.1</version>
</dependency>

Código de muestra:

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

Answer 17

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

Solo pregunté esto en una entrevista ........

Mi respuesta a continuación, pero esto (mencionado anteriormente) es mucho mejor->

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

Mi respuesta es:

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

Answer 18

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

El segundo parámetro es la longitud de salida deseada.

"0" es el relleno de caracteres

Answer 19

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

Answer 20

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