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

¿Cómo dejaste la almohadilla y int con ceros al convertir a un String en java?

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

preguntado el 23 de enero de 09 a las 13:01

¡SIP eso es! mi mal ... lo escribí en mi teléfono. Tampoco necesita la "nueva cadena": Integer.toString (num + 10000) .subString (1) funciona. -

Long.valueOf ("00003400"). ToString (); Integer.valueOf ("00003400"). ToString (); ---> 3400 -

véase también stackoverflow.com/questions/35521278/… para una solución con diagrama -

Hay un problema con el new String(Integer.toString(num + 10000)).substring(1) acercarse si num es mayor que 9999, ijs. -

16 Respuestas

Utiliza la java.lang.String.format(String,Object...) Me gusta esto:

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

para relleno de ceros con una longitud de 5. Para salida hexadecimal, reemplace el d con una x como en "%05x".

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

Respondido 26 Jul 16, 20:07

¿Debo esperar las opciones en String.format ser similar a printf () en C? - Ehtesh Choudhury

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 y ejecutar los dos en Visual VM muestra que el método String.format () acumula tiempo de CPU a aproximadamente 3-4 veces la velocidad de DecimalFormat.format (). - steve ferguson

Y para agregar más de 9 ceros usa algo como %012d - mohammad banisaeid

Esto es para Java 5 y superior. Para 1.4 y DecimalFormat inferior es una alternativa como se muestra aquí javadevnotes.com/java-entero-a-cadena-con-ceros-a la izquierda - JavaDev

¡Hola tios! Tengo algunos problemas al usar: %d can't format java.lang.String arguments - Helio Soares Junior

Digamos que quieres imprimir 11 as 011

Podrías usar un formateador: "%03d".

enter image description here

Puede utilizar este formateador así:

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

respondido 07 mar '18, 05:03

@Omar Koohei de hecho, pero explica el razonamiento detrás de las "constantes mágicas". - bvdb

¡Buena respuesta! Solo un comentario, el F de formato () debe ser f: String.format(...);. - david miguel

¿Qué pasa si no quiero agregar un 0 inicial sino otra letra / número? Gracias - chiperortiz

@chiperortiz afaik no es posible con las herramientas de formato anteriores. En ese caso, calculo los caracteres iniciales requeridos (p. Ej. int prefixLength = requiredTotalLength - String.valueOf(numericValue).length) y luego use un método de repetición de cadena para crear el prefijo requerido. Hay varias formas de repetir cadenas, pero no hay una nativa de Java, afaik: stackoverflow.com/questions/1235179/… - bvdb

Si por alguna razón utiliza Java anterior a 1.5, puede intentarlo con el método Apache Commons Lang

org.apache.commons.lang.StringUtils.leftPad(String str, int size, '0')

Respondido 31 Oct 12, 21:10

Encontré este ejemplo ... 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));
    }
}

Probé esto y:

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

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

contestado el 10 de mayo de 16 a las 18:05

Sí, iba a sugerir DecimalFormat porque no sabía sobre String.format, pero luego vi la respuesta de uzhin. String.format debe ser nuevo. - pablo tomblin

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

En mi caso utilicé la primera opción (DecimalFormat) porque mi número era un Doble - Mauronet

Si el rendimiento es importante en su caso, puede hacerlo usted mismo con menos gastos generales en comparación con el String.format funció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();       
}

Performance

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: 1697ms

Formato de cadena: 38134ms

Respondido el 03 de Septiembre de 13 a las 16:09

Arriba se menciona que el uso de DecimalFormat es más rápido. ¿Tenías alguna nota sobre eso? - Patrick

@Patrick Para el rendimiento de DecimalFormat, consulte también: stackoverflow.com/questions/8553672/… - Stephan

¡Impactante! Es una locura que la función funcione tan mal. Tuve que poner a cero el pad y mostrar una colección de entradas sin firmar que podían oscilar entre 1 y 3 dígitos. Necesitaba funcionar a la velocidad del rayo. Usé este método simple: for( int i : data ) strData += (i > 9 ? (i > 99 ? "" : "0") : "00") + Integer.toString( i ) + "|"; Eso funcionó muy rápido (¡lo siento, no lo cronometré!). - BuvinJ

¿Cómo se compara el rendimiento después de que se ha ejecutado lo suficiente como para que HotSpot lo intente? - Phil

Puedes usar Google Guayaba:

Experto:

<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:

Guava es una biblioteca muy útil, también proporciona muchas características relacionadas con Collections, Caches, Functional idioms, Concurrency, Strings, Primitives, Ranges, IO, Hashing, EventBus, Etc.

Ref: Guayaba Explicado

Respondido 27 Jul 16, 17:07

El código de muestra anterior es solo para uso, no es realmente un código de muestra. El comentario refleja esto, necesitaría "String myPaddedString = Strings.padStart (...)" - jose

Este método en realidad ofrece resultados de rendimiento mucho mejores que JDK String.format / MessageFormatter / DecimalFormatter. - rafalmag

Prueba este:

import java.text.DecimalFormat; 

DecimalFormat df = new DecimalFormat("0000");

String c = df.format(9);   // Output: 0009

String a = df.format(99);  // Output: 0099

String b = df.format(999); // Output: 0999

Respondido 19 Jul 20, 05:07

Así es como puede formatear su cadena sin usar DecimalFormat.

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

09

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

019

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

0119

Respondido 19 Feb 20, 04:02

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

respondido 02 mar '12, 19:03

int x = 1;
System.out.format("%05d",x);

si desea imprimir el texto formateado directamente en la pantalla.

Respondido 24 ago 13, 14:08

Pero OP nunca lo pidió. Internamente String.format y System.out.format llamar al mismo java.util.Formatter implementación. - bsd

... y System.out puede ser redirigido. - Phil

Necesita usar un formateador, el siguiente código usa Formato numérico

    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

respondido 08 nov., 17:10

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

PRODUCCIÓN : 0000811

Respondido 13 Oct 18, 12:10

En este caso, la salida es 0811. - OJVM

Verifique mi código que funcionará para integer 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);

Respondido 24 Jul 14, 11:07

(new char[diff]) por qué - Isaac

replace("\0", "0")que es que - 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 de carácter) con "0" (que es el carácter que necesitamos aquí para el relleno) - Fathah Rehman P.

Aquí hay otra forma de rellenar un número entero con ceros a la izquierda. Puede aumentar el número de ceros según su conveniencia. Se ha agregado un cheque para devolver el mismo valor que en caso de número negativo o un valor mayor o igual a ceros configurado. Puede modificar aún más según sus necesidades.

/**
 * 
 * @author Dinesh.Lomte
 *
 */
public class AddLeadingZerosToNum {
    
    /**
     * 
     * @param args
     */
    public static void main(String[] args) {
        
        System.out.println(getLeadingZerosToNum(0));
        System.out.println(getLeadingZerosToNum(7));
        System.out.println(getLeadingZerosToNum(13));
        System.out.println(getLeadingZerosToNum(713));
        System.out.println(getLeadingZerosToNum(7013));
        System.out.println(getLeadingZerosToNum(9999));
    }
    /**
     * 
     * @param num
     * @return
     */
    private static String getLeadingZerosToNum(int num) {
        // Initializing the string of zeros with required size
        String zeros = new String("0000");
        // Validating if num value is less then zero or if the length of number 
        // is greater then zeros configured to return the num value as is
        if (num < 0 || String.valueOf(num).length() >= zeros.length()) {
            return String.valueOf(num);
        }
        // Returning zeros in case if value is zero.
        if (num == 0) {
            return zeros;
        }
        return new StringBuilder(zeros.substring(0, zeros.length() - 
                String.valueOf(num).length())).append(
                        String.valueOf(num)).toString();
    }
}

Entrada

0

7

13

713

7013

9999

Salida

0000

0007

0013

7013

9999

Respondido 15 ago 20, 15:08

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 pensar para descubrir cómo funciona.

Respondido 05 Oct 11, 20:10

¿El único problema? Pruébalo con un negativo number o con un width mayor de 18. - user85421

Buen punto. Y supongo que hace más de lo que se solicitó, ya que se trunca en el ancho (que no se solicitó explícitamente pero que generalmente se necesita). Es una pena que String.format () de Java (dolorosamente lento en comparación) no admita anchos variables y no admita precisión en absoluto para especificadores de enteros. - Johncurrier

No se necesitan paquetes:

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

Esto rellenará la cadena a 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 cuerda acolchada grande), pero me gusta.

contestado el 09 de mayo de 17 a las 13:05

Hmm ... me gusta. - Kartik Chugh

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.