¿Cómo puedo rellenar un entero con ceros a la izquierda?

1022

¿Cómo dejaste el pad an intcon ceros al convertir a a Stringen java?

Básicamente, estoy buscando rellenar enteros 9999con ceros a la izquierda (por ejemplo, 1 = 0001).

Omar Kooheji
fuente
2
¡SIP eso es! mi mal ... lo escribí en mi teléfono. Tampoco necesita la "nueva cadena": Integer.toString (num + 10000) .subString (1) funciona.
Randyaa
Long.valueOf ("00003400"). ToString (); Integer.valueOf ("00003400"). ToString (); ---> 3400
frekele
1
vea también stackoverflow.com/questions/35521278/… para una solución con diagrama
bvdb
Sin embargo, hay un problema con el new String(Integer.toString(num + 10000)).substring(1)enfoque si numes mayor que 9999, ijs.
Felype

Respuestas:

1697

Usar java.lang.String.format(String,Object...)así:

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

para el relleno cero con una longitud de 5. Para la salida hexadecimal, reemplace el dcon un xcomo en "%05x".

Las opciones de formato completo se documentan como parte de java.util.Formatter.

Yoni Roit
fuente
1
¿Debo esperar que las opciones String.formatsean similares a printf () en C?
Ehtesh Choudhury
13
Si tiene que hacer esto para una lista grande de valores, el rendimiento de DecimalFormat es al menos 3 veces mejor que String.format (). Estoy en el proceso de ajustar el rendimiento yo mismo y ejecutar los dos en Visual VM muestra el método String.format () acumulando tiempo de CPU a aproximadamente 3-4 veces la tasa de DecimalFormat.format ().
Steve Ferguson
10
Y para agregar más de 9 ceros use algo como%012d
Mohammad Banisaeid
2
Esto es para Java 5 y superior. Para 1.4 y anteriores, DecimalFormat es una alternativa como se muestra aquí javadevnotes.com/java-integer-to-string-with-leading-zeros
JavaDev
1
¡Hola chicos! Tengo algunos problemas al usar:%d can't format java.lang.String arguments
Helio Soares Junior
116

Digamos que quieres imprimir 11como011

Se puede usar un formateador : "%03d".

ingrese la descripción de la imagen aquí

Puede usar este formateador de esta manera:

int a = 11;
String with3digits = String.format("%03d", a);
System.out.println(with3digits);

Alternativamente, algunos métodos de Java admiten directamente estos formateadores:

System.out.printf("%03d", a);
bvdb
fuente
55
@Omar Koohei de hecho, pero explica el razonamiento detrás de las "constantes mágicas".
bvdb
¡Buena respuesta! Sólo un comentario, el Fde formato () debe ser f: String.format(...);.
David Miguel el
¿Qué sucede si no quiero agregar un 0 inicial sino otra letra / número? gracias
chiperortiz
1
@chiperortiz afaik no es posible con las herramientas de formato anteriores. En ese caso, calculo los caracteres iniciales necesarios (p int prefixLength = requiredTotalLength - String.valueOf(numericValue).length. Ej. ) Y luego uso un método de cadena de repetición para crear el prefijo requerido. Hay varias formas de repetir cadenas, pero no hay una Java nativa, afaik: stackoverflow.com/questions/1235179/…
bvdb
114

Si por alguna razón usa Java pre 1.5, puede intentar con el método Lang de Apache Commons

org.apache.commons.lang.StringUtils.leftPad(String str, int size, '0')
Boris Pavlović
fuente
29

Encontré este ejemplo ... Lo probaré ...

import java.text.DecimalFormat;
class TestingAndQualityAssuranceDepartment
{
    public static void main(String [] args)
    {
        int x=1;
        DecimalFormat df = new DecimalFormat("00");
        System.out.println(df.format(x));
    }
}

Probado esto y:

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

Ambos funcionan, para mis propósitos creo que String.Format es mejor y más sucinto.

Omar Kooheji
fuente
1
Sí, iba a sugerir DecimalFormat porque no sabía sobre String.format, pero luego vi la respuesta de uzhin. String.format debe ser nuevo.
Paul Tomblin el
Es similar a cómo lo haría en .Net Excepto que la forma .Net se ve mejor para números pequeños.
Omar Kooheji el
En mi caso, utilicé la primera opción (DecimalFormat) porque mi número era un Double
mauronet el
21

Si el rendimiento es importante en su caso, puede hacerlo usted mismo con menos sobrecarga en comparación con la String.formatfunción:

/**
 * @param in The integer value
 * @param fill The number of digits to fill
 * @return The given value left padded with the given number of digits
 */
public static String lPadZero(int in, int fill){

    boolean negative = false;
    int value, len = 0;

    if(in >= 0){
        value = in;
    } else {
        negative = true;
        value = - in;
        in = - in;
        len ++;
    }

    if(value == 0){
        len = 1;
    } else{         
        for(; value != 0; len ++){
            value /= 10;
        }
    }

    StringBuilder sb = new StringBuilder();

    if(negative){
        sb.append('-');
    }

    for(int i = fill; i > len; i--){
        sb.append('0');
    }

    sb.append(in);

    return sb.toString();       
}

Actuación

public static void main(String[] args) {
    Random rdm;
    long start; 

    // Using own function
    rdm = new Random(0);
    start = System.nanoTime();

    for(int i = 10000000; i != 0; i--){
        lPadZero(rdm.nextInt(20000) - 10000, 4);
    }
    System.out.println("Own function: " + ((System.nanoTime() - start) / 1000000) + "ms");

    // Using String.format
    rdm = new Random(0);        
    start = System.nanoTime();

    for(int i = 10000000; i != 0; i--){
        String.format("%04d", rdm.nextInt(20000) - 10000);
    }
    System.out.println("String.format: " + ((System.nanoTime() - start) / 1000000) + "ms");
}

Resultado

Función propia: 1697 ms

Formato de cadena: 38134 ms

das Keks
fuente
1
Arriba hay una mención del uso de DecimalFormat siendo más rápido. ¿Tienes alguna nota sobre eso?
Patrick
@Patrick Para el rendimiento de DecimalFormat, consulte también: stackoverflow.com/questions/8553672/…
Stephan
¡Impactante! Es una locura que funciona tan mal. Tuve que poner a cero el pad y mostrar una colección de entradas sin signo que podrían oscilar entre 1 y 3 dígitos. Necesitaba trabajar a la velocidad del rayo. Utilicé este método simple: for( int i : data ) strData += (i > 9 ? (i > 99 ? "" : "0") : "00") + Integer.toString( i ) + "|";funcionó muy rápido (¡perdón, no lo cronometré!).
BuvinJ
¿Cómo se compara el rendimiento después de que se haya ejecutado lo suficiente como para que HotSpot tenga un crack?
Phil
16

Puedes usar Google Guava :

Maven

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

Código de muestra:

String paddedString1 = Strings.padStart("7", 3, '0'); //"007"
String paddedString2 = Strings.padStart("2020", 3, '0'); //"2020"

Nota:

Guavaes una biblioteca de gran utilidad, sino que también ofrece un montón de características que se referían a Collections, Caches, Functional idioms, Concurrency, Strings, Primitives, Ranges, IO, Hashing, EventBus, etc.

Ref: Guayaba Explicada

aunque
fuente
1
El código de muestra anterior es solo de uso, no es realmente un código de muestra. El comentario refleja esto, necesitaría "String myPaddedString = Strings.padStart (...)"
JoeG
2
Este método en realidad ofrece resultados de rendimiento mucho mejores que JDK String.format / MessageFormatter / DecimalFormatter.
rafalmag
10

Prueba este:

import java.text.DecimalFormat; 

DecimalFormat df = new DecimalFormat("0000");
String c = df.format(9);   // 0009
String a = df.format(99);  // 0099
String b = df.format(999); // 0999
Brijesh Patel
fuente
3

Aunque muchos de los enfoques anteriores son buenos, a veces necesitamos formatear enteros y flotantes. Podemos usar esto, particularmente cuando necesitamos rellenar un número particular de ceros a la izquierda y a la derecha de los números decimales.

import java.text.NumberFormat;  
public class NumberFormatMain {  

public static void main(String[] args) {  
    int intNumber = 25;  
    float floatNumber = 25.546f;  
    NumberFormat format=NumberFormat.getInstance();  
    format.setMaximumIntegerDigits(6);  
    format.setMaximumFractionDigits(6);  
    format.setMinimumFractionDigits(6);  
    format.setMinimumIntegerDigits(6);  

    System.out.println("Formatted Integer : "+format.format(intNumber).replace(",",""));  
    System.out.println("Formatted Float   : "+format.format(floatNumber).replace(",",""));  
 }    
}  
Deepak
fuente
2
int x = 1;
System.out.format("%05d",x);

si desea imprimir el texto formateado directamente en la pantalla.

Shashi
fuente
1
Pero OP nunca lo pidió. Internamente String.formaty System.out.formatllamar a la misma java.util.Formatterimplementación.
bsd
... y System.out puede ser redirigido.
Phil
1

Use la clase DecimalFormat, así:

NumberFormat formatter = new DecimalFormat("0000"); //i use 4 Zero but you can also another number
System.out.println("OUTPUT : "+formatter.format(811)); 

SALIDA: 0000811

Shomu
fuente
1

Aquí es cómo puede formatear su cadena sin usar DecimalFormat.

String.format("%02d", 9)

09

String.format("%03d", 19)

019

String.format("%04d", 119)

0119

Morgan Koh
fuente
0

Verifique mi código que funcionará para entero y String.

Supongamos que nuestro primer número es 2. Y queremos agregar ceros a eso para que la longitud de la cadena final sea 4. Para eso, puede usar el siguiente código

    int number=2;
    int requiredLengthAfterPadding=4;
    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);
Fathah Rehman P
fuente
(new char[diff])por qué
Isaac
replace("\0", "0")qué es ... qué
Isaac
@Isaac - Primero creé una matriz de caracteres, y usando esa matriz de caracteres creé una cadena. Luego reemplacé el carácter nulo (que es el valor predeterminado del tipo char) con "0" (que es el carácter que necesitamos aquí para el relleno)
Fathah Rehman P
0

Debe usar un formateador, el siguiente código usa NumberFormat

    int inputNo = 1;
    NumberFormat nf = NumberFormat.getInstance();
    nf.setMaximumIntegerDigits(4);
    nf.setMinimumIntegerDigits(4);
    nf.setGroupingUsed(false);

    System.out.println("Formatted Integer : " + nf.format(inputNo));

Salida: 0001

JoBⅈN
fuente
-2
public static String zeroPad(long number, int width) {
   long wrapAt = (long)Math.pow(10, width);
   return String.valueOf(number % wrapAt + wrapAt).substring(1);
}

El único problema con este enfoque es que te hace ponerte el sombrero de pensamiento para descubrir cómo funciona.

johncurrier
fuente
55
¿El único problema? Pruébelo con un valor negativo numbero widthmayor que 18.
user85421
2
Buen punto. Y supongo que hace más de lo solicitado, ya que se trunca en el ancho (que no se solicitó explícitamente, pero generalmente se necesita). Es una pena que el String.format () de Java (dolorosamente lento en comparación) no admita anchos variables y no admita precisión para los especificadores de enteros.
johncurrier
-3

No se necesitan paquetes:

String paddedString = i < 100 ? i < 10 ? "00" + i : "0" + i : "" + i;

Esto rellenará la cadena con tres caracteres y es fácil agregar una parte más para cuatro o cinco. Sé que esta no es la solución perfecta de ninguna manera (especialmente si quieres una cadena acolchada grande), pero me gusta.

NoShadowKick
fuente
1
Hmm ... me gusta.
Kartik Chugh