Java 如何在整数的左边填充零？

在java中转换为

字符串时，如何将
int
填充为零

我基本上是想用前导零（例如1=
0001
）填充到
9999
的整数。
发现了这个例子。。。将测试

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

对此进行了测试，并：

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

这两种方法都有效，我认为String.Format更好、更简洁。
如下使用：

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

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

用于长度为5的零填充。对于十六进制输出，将
d
替换为
x
，如
“%05x”

完整的格式选项作为的一部分进行了说明。
如果出于任何原因使用1.5版之前的Java，则可以尝试使用Apache Commons Lang方法

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

虽然上述许多方法都很好，但有时我们需要格式化整数和浮点。我们可以使用它，特别是当我们需要在十进制数的左边和右边填充特定数量的零时

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

如果您想将格式化文本直接打印到屏幕上。
如果性能对您来说很重要，您可以自己完成，与
字符串相比，开销更小。格式化功能：

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

性能

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

结果

自身功能：1697ms

字符串。格式：38134ms
检查我的代码，该代码将用于整数和字符串

假设我们的第一个数字是2。我们想给它加上零，这样最后一个字符串的长度将是4。为此，您可以使用以下代码

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

int number=2；
填充后所需的int长度=4；
字符串resultString=Integer.toString（数字）；
int inputStringLengh=resultString.length（）；
int diff=填充inputStringLengh后所需的长度；
如果（inputStringLengh您可以使用：

Maven:

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

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

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

注意：

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

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

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

Guava
是一个非常有用的库，它还提供了许多与
集合
，
缓存
，
功能惯用法
，
并发
，
字符串
，
原语
，
范围
，
IO
，
哈希
，
事件总线
等相关的功能

Ref:
假设您想将
11
打印为
011

您可以使用格式化程序：
%03d


您可以这样使用此格式化程序：

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

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

或者，一些java方法直接支持这些格式化程序：

System.out.printf("%03d", a);

无需软件包：

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

String paddedString=i<100？i<10？+00？+i:0？+i:+i；

这将把字符串填充到三个字符，并且很容易为四个或五个字符添加一部分。我知道这在任何方面都不是完美的解决方案（特别是如果您想要一个大的填充字符串），但我喜欢它。
您需要使用格式化程序，以下代码使用

产出：0001

试试这个：

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

使用DecimalFormat类，如下所示：

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

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

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

输出：0000811
以下是如何在不使用
DecimalFormat
的情况下格式化字符串

String.format（“%02d”，9）

09

String.format（“%03d”，19）

019

String.format（“%04d”，119）

0119

这里是另一种在整数左边填充零的方法。您可以根据自己的方便增加零的数量。添加了一个检查，以返回与负数或大于或等于零的配置值相同的值。您可以根据需要进一步修改

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

/**
* 
*@author Dinesh.lomete
*
*/
公共类AddLeadingZerosToNum{
/**
* 
*@param args
*/
公共静态void main（字符串[]args）{
系统输出打印LN（getLeadingZerosToNum（0））；
系统输出打印LN（getLeadingZerosToNum（7））；
系统输出打印LN（getLeadingZerosToNum（13））；
系统输出打印LN（getLeadingZerosToNum（713））；
系统输出打印LN（getLeadingZerosToNum（7013））；
系统输出打印LN（getLeadingZerosToNum（9999））；
}
/**
* 
*@param num
*@返回
*/
私有静态字符串getLeadingZerosToNum（int num）{
//正在初始化具有所需大小的零字符串
字符串零=新字符串（“0000”）；
//正在验证num值是否小于零或num的长度是否为
//大于配置为按原样返回num值的零
if（num<0 | | String.valueOf（num.length（）>=zeros.length（））{
返回字符串.valueOf（num）；
}
//如果值为零，则返回零。
如果（num==0）{
返回零；
}
返回新的StringBuilder（zeros.substring（0，zeros.length（）-
String.valueOf（num.length（））.append(
String.valueOf（num））.toString（）；
}
}

输入

0

七,

十三,

713

7013

9999

输出

万

0007

0013

7013

9999
是的，我本来打算建议使用DecimalFormat，因为我不知道String.format，但后来我看到了uzhin的答案。String.format肯定是新的。它与在.Net中的做法类似，只是.Net的方式对于小数字更合适。在我的例子中，我使用了第一个选项（DecimalFormat）因为我的数字是双精度的，我是否应该期望
String.format
中的选项类似于C中的printf（）？如果必须对大量值执行此操作，DecimalFormat的性能至少是String.format（）的3倍。我正在自己做一些性能调优，并在Visual VM中运行这两个函数。String.format（）方法以大约3-4倍于DecimalFormat.format（）的速度累积CPU时间。要添加9个以上的零，请使用类似
%012d
的方法，这适用于Java 5及以上版本。对于1.4及以下版本，DecimalFormat是