Como posso preencher um número inteiro com zeros à esquerda?

1022

Como você deixou um pad intcom zeros ao converter para um Stringem java?

Basicamente, estou procurando preencher números inteiros 9999com zeros à esquerda (por exemplo, 1 = 0001).

Omar Kooheji
fonte
2
Sim, é isso! meu mal ... eu digitei no meu telefone. Você não precisa da "nova String": Integer.toString (num + 10000) .subString (1) funciona.
Randyaa
Long.valueOf ("00003400"). ToString (); Integer.valueOf ("00003400"). ToString (); ---> 3400
frekele
1
ver também stackoverflow.com/questions/35521278/... para uma solução com diagrama
bvdb
Há um problema com a new String(Integer.toString(num + 10000)).substring(1)abordagem, se numfor maior que 9999, ijs.
Felype

Respostas:

1696

Use java.lang.String.format(String,Object...)assim:

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

para preenchimento zero com um comprimento de 5. Para saída hexadecimal, substitua por dcom um xcomo em "%05x".

As opções de formatação completas estão documentadas como parte de java.util.Formatter.

Yoni Roit
fonte
1
Devo esperar que as opções String.formatsejam semelhantes a printf () em C?
Ehtesh Choudhury
13
Se você precisar fazer isso para obter uma grande lista de valores, o desempenho de DecimalFormat será pelo menos três vezes melhor que String.format (). Estou no processo de ajustar o desempenho por conta própria e executar os dois no Visual VM mostra o método String.format () acumulando o tempo da CPU em cerca de 3-4 vezes a taxa de DecimalFormat.format ().
Steve Ferguson
10
E para adicionar mais de 9 zeros usar algo como%012d
Mohammad Banisaeid
2
Isso é para Java 5 e acima. Para 1,4 e inferior DecimalFormat é uma alternativa, como mostrado aqui javadevnotes.com/java-integer-to-string-with-leading-zeros
JavaDev
1
Oi pessoal! Estou com alguns problemas ao usar:%d can't format java.lang.String arguments
Helio Soares Junior
116

Digamos que você queira imprimir 11como011

Você poderia usar um formatador : "%03d".

insira a descrição da imagem aqui

Você pode usar este formatador assim:

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

Como alternativa, alguns métodos java suportam diretamente esses formatadores:

System.out.printf("%03d", a);
bvdb
fonte
5
@ Omar Koohei, de fato, mas explica o raciocínio por trás das "constantes mágicas".
bvdb
Boa resposta! Apenas um comentário, o Fde format () deve ser f: String.format(...);.
David Miguel
e se eu não quiser acrescentar um 0 inicial, mas outra letra / número? graças
chiperortiz
1
@chiperortiz afaik não é possível com as ferramentas de formatação acima. Nesse caso, calculo os caracteres iniciais necessários (por exemplo int prefixLength = requiredTotalLength - String.valueOf(numericValue).length) e, em seguida, uso um método de sequência repetida para criar o prefixo necessário. Existem várias maneiras de repetir seqüências de caracteres, mas não há uma nativa em java, como: stackoverflow.com/questions/1235179/…
bvdb
114

Se, por algum motivo, você usar o Java anterior a 1.5, poderá tentar com o método Apache Commons Lang

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

Encontrei este exemplo ... Testará ...

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

Testou isso e:

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

Ambos funcionam, para meus propósitos, acho que String.Format é melhor e mais sucinto.

Omar Kooheji
fonte
1
Sim, eu sugeriria DecimalFormat porque não sabia sobre String.format, mas então vi a resposta de uzhin. String.format deve ser novo.
23415 Paul Tomblin
É parecido com o que você faria em .Net Exceto que a maneira .Net parece melhor para pequenos números.
Omar Kooheji
No meu caso eu usei a primeira opção (DecimalFormat) porque o meu número era um duplo
mauronet
21

Se o desempenho for importante no seu caso, você poderá fazê-lo com menos sobrecarga em comparação com a String.formatfunção:

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

atuação

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

Função própria: 1697ms

String.format: 38134ms

das Keks
fonte
1
Acima, há uma menção de usar DecimalFormat sendo mais rápido. Você tinha alguma nota sobre isso?
22414 Patrick
Desempenho @Patrick Para DecimalFormat veja também: stackoverflow.com/questions/8553672/...
Stephan
Chocante! É loucura que a função funcione tão mal. Eu tive que zerar o pad e exibir uma coleção de entradas não assinadas que podiam variar de 1 a 3 dígitos. Precisava trabalhar muito rápido. Eu usei esse método simples: for( int i : data ) strData += (i > 9 ? (i > 99 ? "" : "0") : "00") + Integer.toString( i ) + "|";isso funcionou muito rapidamente (desculpe, não dei tempo!).
precisa saber é o seguinte
Como o desempenho se compara após ser executado o suficiente para o HotSpot ter uma falha nele?
Phil
16

Você pode usar o Google Guava :

Maven:

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

Código de amostra:

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

Nota:

Guavaé uma biblioteca muito útil, ele também oferece muitos recursos que se referem a Collections, Caches, Functional idioms, Concurrency, Strings, Primitives, Ranges, IO, Hashing, EventBus, etc

Ref: GuavaExplicado

Tho
fonte
1
O código de amostra acima é apenas para uso, não é realmente um código de amostra. O comentário reflete isso, você precisaria de "String myPaddedString = Strings.padStart (...)"
JoeG
2
Na verdade, esse método fornece resultados de desempenho muito melhores que o JDK String.format / MessageFormatter / DecimalFormatter.
Rafalmag
10

Tente 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
fonte
3

Embora muitas das abordagens acima sejam boas, às vezes precisamos formatar números inteiros e flutuantes. Podemos usar isso, principalmente quando precisamos preencher um número específico de zeros à esquerda e à direita de números decimais.

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
fonte
2
int x = 1;
System.out.format("%05d",x);

se você deseja imprimir o texto formatado diretamente na tela.

Shashi
fonte
1
Mas a OP nunca pediu isso. Internamente String.formate System.out.formatchame a mesma java.util.Formatterimplementação.
BSD
... e System.out podem ser redirecionados.
Phil
1

Use a classe DecimalFormat, assim:

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

OUTPUT: 0000811

Shomu
fonte
1

Aqui está como você pode formatar sua string sem usar DecimalFormat.

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

09

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

019

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

0119

Morgan Koh
fonte
0

Verifique meu código que funcionará para inteiro e String.

Suponha que nosso primeiro número seja 2. E queremos adicionar zeros a isso, para que o comprimento da string final seja 4. Para isso, você pode usar o seguinte 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
fonte
(new char[diff])por que
Isaac
replace("\0", "0")o que é ... o que
Isaac
@ Isaac - Primeiro, criei uma matriz de caracteres e, usando essa matriz, criei uma string. Em seguida, substituí o caractere nulo (que é o valor padrão do tipo de caractere) por "0" (que é o caracter que precisamos aqui para preenchimento)
Fathah Rehman P
0

Você precisa usar um Formatador, o código a seguir 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));

Saída: 0001

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

O único problema com essa abordagem é que ela faz com que você se vista para descobrir como ela funciona.

johncurrier
fonte
5
O único problema? Tente com um valor negativo numberou widthsuperior a 18. #
user85421 5/11
2
Bom ponto. E acho que ele faz mais do que foi solicitado, pois trunca na largura (o que não foi explicitamente solicitado, mas geralmente é necessário). É uma pena que o Java (dolorosamente lento em comparação) String.format () não suporte larguras variáveis ​​e não suporte precisão para especificadores de número inteiro.
51111
-3

Não são necessários pacotes:

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

Isso irá preencher a seqüência de caracteres com três caracteres, e é fácil adicionar uma parte a mais por quatro ou cinco. Sei que essa não é a solução perfeita de maneira alguma (especialmente se você deseja uma corda grande e acolchoada), mas eu gosto.

NoShadowKick
fonte
1
Hmm ... eu gosto disso.
Kartik Chugh