如何在左侧用零填充整数？答案

【问题标题】：How can I pad an integer with zeros on the left?如何在左侧用零填充整数？
【发布时间】：2010-10-03 03:55:46
【问题描述】：

在 java 中转换为 String 时，如何将 int 用零填充？

我基本上希望用前导零填充最大为 9999 的整数（例如 1 = 0001）。

【问题讨论】：

是的，就是这样！我的错...我在手机上输入了它。您也不需要“新字符串”： Integer.toString(num+10000).subString(1) 有效。
Long.valueOf("00003400").toString(); Integer.valueOf("00003400").toString(); --->3400
另请参阅stackoverflow.com/questions/35521278/… 以获取图表解决方案
如果 num 大于 9999，则 new String(Integer.toString(num + 10000)).substring(1) 方法会出现问题，ijs。

【解决方案1】：

像这样使用java.lang.String.format(String,Object...)：

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

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

完整的格式化选项记录为java.util.Formatter 的一部分。

【讨论】：

我是否应该期望 String.format 中的选项类似于 C 中的 printf()？
如果必须为大量值执行此操作，DecimalFormat 的性能至少比 String.format() 好 3 倍。我正在自己进行一些性能调整，并在 Visual VM 中运行这两个显示 String.format() 方法以大约 3-4 倍于 DecimalFormat.format() 的速率累积 CPU 时间。
要添加超过 9 个零，请使用 %012d
这适用于 Java 5 及更高版本。对于 1.4 和更低版本，DecimalFormat 是一种替代方法，如下所示javadevnotes.com/java-integer-to-string-with-leading-zeros
大家好！我在使用时遇到了一些问题：%d can't format java.lang.String arguments

【解决方案2】：

假设您要将11 打印为011

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

你可以像这样使用这个格式化程序：

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

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

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

【讨论】：

@Omar Koohei 确实如此，但它解释了“魔法常数”背后的原因。
不错的答案！只是注释，format() 的F 应该是f: String.format(...);。
如果我不想添加前导 0 而添加另一个字母/数字怎么办？谢谢
@chiperortiz afaik 使用上述格式化工具是不可能的。在这种情况下，我计算所需的前导字符（例如int prefixLength = requiredTotalLength - String.valueOf(numericValue).length），然后使用重复字符串方法来创建所需的前缀。有多种方法可以重复字符串，但没有原生的 java 方法，afaik：stackoverflow.com/questions/1235179/…

【解决方案3】：

如果您出于任何原因使用 1.5 之前的 Java，则可以尝试使用 Apache Commons Lang 方法

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

【讨论】：

【解决方案4】：

找到这个例子...将测试...

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 更好更简洁。

【讨论】：

是的，我本来打算建议DecimalFormat，因为我不知道String.format，但后来我看到了uzhin的回答。 String.format 必须是新的。
这与您在 .Net 中的操作方式相似，只是 .Net 方式对于小数字来说看起来更好。
就我而言，我使用了第一个选项（DecimalFormat），因为我的号码是 Double

【解决方案5】：

试试这个：

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

【讨论】：

【解决方案6】：

如果在您的情况下性能很重要，与String.format 函数相比，您可以用更少的开销自行完成：

/**
 * @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

String.format： 38134ms

【讨论】：

上面提到了使用 DecimalFormat 更快。你对此有什么注意事项吗？
@Patrick 有关 DecimalFormat 性能，另请参阅：stackoverflow.com/questions/8553672/…
令人震惊！功能如此糟糕，真是太疯狂了。我必须归零并显示一组无符号整数，其范围可能在 1 到 3 位之间。它需要以闪电般的速度工作。我使用了这个简单的方法：for( int i : data ) strData += (i > 9 ? (i > 99 ? "" : "0") : "00") + Integer.toString( i ) + "|"; 效果非常好（抱歉我没有计时！）。
在运行到足以让 HotSpot 破解它之后，性能比较如何？

【解决方案7】：

你可以使用Google Guava:

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"

注意：

Guava 是一个非常有用的库，它还提供了很多与Collections、Caches、Functional idioms、Concurrency、Strings、Primitives、Ranges、@987654333 相关的功能@、Hashing、EventBus 等

参考：GuavaExplained

【讨论】：

以上示例代码仅供参考，并非真正的示例代码。评论反映了这一点，您需要 "String myPaddedString = Strings.padStart(...)"
这个方法实际上提供了比JDK String.format / MessageFormatter / DecimalFormatter 更好的性能结果。

【解决方案8】：

以下是如何在不使用DecimalFormat 的情况下格式化字符串。

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

09

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

019

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

0119

【讨论】：

【解决方案9】：

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

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

【讨论】：

【解决方案10】：

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

如果您想将格式化文本直接打印到屏幕上。

【讨论】：

但 OP 从未要求过它。在内部 String.format 和 System.out.format 调用相同的 java.util.Formatter 实现。
... 和 System.out 可以重定向。

【解决方案11】：

你需要使用Formatter，下面的代码使用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));

输出：0001

【讨论】：

【解决方案12】：

使用 DecimalFormat 类，如下所示：

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

输出： 0000811

【讨论】：

在这种情况下，输出为 0811。

【解决方案13】：

您可以像这样在字符串中添加前导 0。定义一个字符串，它将是您想要的字符串的最大长度。就我而言，我需要一个只有 9 个字符长的字符串。

String d = "602939";
d = "000000000".substring(0, (9-d.length())) + d;
System.out.println(d);

输出：000602939

【讨论】：

【解决方案14】：

检查适用于整数和字符串的代码。

假设我们的第一个数字是 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);

【讨论】：

(new char[diff]) 为什么
replace("\0", "0")what is... what
@Isaac - 首先我创建了一个 char 数组，并使用该 char 数组创建了一个字符串。然后我用“0”替换了空字符（这是char类型的默认值）（这是我们这里需要填充的char）

【解决方案15】：

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

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

输入

0

7

13

713

7013

9999

输出

0000

0007

0013

7013

9999

【讨论】：

【解决方案16】：

不需要任何包：

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

这会将字符串填充为三个字符，并且很容易为四五个字符添加更多部分。我知道这无论如何都不是完美的解决方案（特别是如果你想要一个大的填充字符串），但我喜欢它。

【讨论】：

嗯...我喜欢。