Question

我见过类似的问题here和here。

但是我没有得到如何用Zero填充String。

输入：“129018” 输出：“0000129018”

总输出长度应为TEN。

Answer 1

如果您的字符串仅包含数字，则可以将其设为整数，然后执行填充：

String.format("%010d", Integer.parseInt(mystring));

如果不是I would like to know how it can be done。

Answer 2

String paddedString = org.apache.commons.lang.StringUtils.leftPad("129018", 10, "0")

第二个参数是所需的输出长度

“0”是填充字符

Answer 3

这将填充任何字符串，总宽度为10，而不必担心解析错误：

String unpadded = "12345"; 
String padded = "##########".substring(unpadded.length()) + unpadded;

//unpadded is "12345"
//padded   is "#####12345"

如果你想要右键填充：

String unpadded = "12345"; 
String padded = unpadded + "##########".substring(unpadded.length());

//unpadded is "12345"
//padded   is "12345#####"

您可以将“＃”字符替换为您要填充的任何字符，重复您希望字符串总宽度的次数。例如。如果你想在左边添加零，以便整个字符串长15个字符：

String unpadded = "12345"; 
String padded = "000000000000000".substring(unpadded.length()) + unpadded;

//unpadded is "12345"
//padded   is "000000000012345"

这对khachik的答案的好处是，它不使用Integer.parseInt，它可以抛出异常（例如，如果要填充的数字太大，如12147483647）。缺点是，如果你填充的内容已经是int，那么你必须将它转换为String并返回，这是不可取的。

所以，如果你确定它是一个int，那么khachik的答案很有效。如果没有，那么这是一种可能的策略。

Answer 4

String str = "129018";
StringBuilder sb = new StringBuilder();

for (int toPrepend=10-str.length(); toPrepend>0; toPrepend--) {
    sb.append('0');
}

sb.append(str);
String result = sb.toString();

Answer 5

String str = "129018";
String str2 = String.format("%10s", str).replace(' ', '0');
System.out.println(str2);

Answer 6

您可以使用apache commons StringUtils

StringUtils.leftPad("129018", 10, "0");

https://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/StringUtils.html#leftPad(java.lang.String,%20int,%20char)

Answer 7

格式化字符串使用

import org.apache.commons.lang.StringUtils;

public class test {

    public static void main(String[] args) {

        String result = StringUtils.leftPad("wrwer", 10, "0");
        System.out.println("The String : " + result);

    }
}

输出：字符串：00000wrwer

第一个参数是要格式化的字符串，第二个参数是所需输出长度的长度，第三个参数是用于填充字符串的char。

使用该链接下载jar http://commons.apache.org/proper/commons-lang/download_lang.cgi

Answer 8

如果你需要性能并知道字符串的最大大小，请使用：

String zeroPad = "0000000000000000";
String str0 = zeroPad.substring(str.length()) + str;

请注意最大字符串大小。如果它大于StringBuffer大小，您将获得java.lang.StringIndexOutOfBoundsException。

Answer 9

一个老问题，但我也有两种方法。

对于固定（预定义）长度：

    public static String fill(String text) {
        if (text.length() >= 10)
            return text;
        else
            return "0000000000".substring(text.length()) + text;
    }

对于可变长度：

    public static String fill(String text, int size) {
        StringBuilder builder = new StringBuilder(text);
        while (builder.length() < size) {
            builder.append('0');
        }
        return builder.toString();
    }

Answer 10

使用Google Guava：

<强>的Maven：

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

示例代码：

Strings.padStart("129018", 10, '0') returns "0000129018"

Answer 11

我更喜欢这段代码：

public final class StrMgr {

    public static String rightPad(String input, int length, String fill){                   
        String pad = input.trim() + String.format("%"+length+"s", "").replace(" ", fill);
        return pad.substring(0, length);              
    }       

    public static String leftPad(String input, int length, String fill){            
        String pad = String.format("%"+length+"s", "").replace(" ", fill) + input.trim();
        return pad.substring(pad.length() - length, pad.length());
    }
}

然后：

System.out.println(StrMgr.leftPad("hello", 20, "x")); 
System.out.println(StrMgr.rightPad("hello", 20, "x"));

Answer 12

这是另一种方法：

int pad = 4;
char[] temp = (new String(new char[pad]) + "129018").toCharArray()
Arrays.fill(temp, 0, pad, '0');
System.out.println(temp)

Answer 13

基于@Haroldo Macêdo's answer，我在自定义Utils类中创建了一个方法，例如

/**
 * Left padding a string with the given character
 *
 * @param str     The string to be padded
 * @param length  The total fix length of the string
 * @param padChar The pad character
 * @return The padded string
 */
public static String padLeft(String str, int length, String padChar) {
    String pad = "";
    for (int i = 0; i < length; i++) {
        pad += padChar;
    }
    return pad.substring(str.length()) + str;
}

然后拨打Utils.padLeft(str, 10, "0");

Answer 14

这是我的解决方案：

String s = Integer.toBinaryString(5); //Convert decimal to binary
int p = 8; //preferred length
for(int g=0,j=s.length();g<p-j;g++, s= "0" + s);
System.out.println(s);

输出： 00000101

Answer 15

右边填充，固定长度为10： String.format（“％1 $ -10s”，“abc”）左边填充固定长度为10： String.format（“％1 $ 10s”，“abc”）

Answer 16

Satish的解决方案在预期答案中非常好。我希望通过将变量n添加到格式字符串而不是10个字符来使其更加通用。

int maxDigits = 10;
String str = "129018";
String formatString = "%"+n+"s";
String str2 = String.format(formatString, str).replace(' ', '0');
System.out.println(str2);

这适用于大多数情况

Answer 17

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

假设我们的第一个数字是129018.并且我们想要为此添加零，以便最终字符串的长度为10.为此您可以使用以下代码

    int number=129018;
    int requiredLengthAfterPadding=10;
    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);

Answer 18

这是一个基于String.format的解决方案，它适用于字符串，适用于可变长度。

public static String PadLeft(String stringToPad, int padToLength){
    String retValue = null;
    if(stringToPad.length() < padToLength) {
        retValue = String.format("%0" + String.valueOf(padToLength - stringToPad.length()) + "d%s",0,stringToPad);
    }
    else{
        retValue = stringToPad;
    }
    return retValue;
}

public static void main(String[] args) {
    System.out.println("'" + PadLeft("test", 10) + "'");
    System.out.println("'" + PadLeft("test", 3) + "'");
    System.out.println("'" + PadLeft("test", 4) + "'");
    System.out.println("'" + PadLeft("test", 5) + "'");
}

<强>输出： '000000test' '测试' '测试' '0test'

Answer 19

    int number = -1;
    int holdingDigits = 7;
    System.out.println(String.format("%0"+ holdingDigits +"d", number));

刚在接受采访时问到这个问题........

我的答案如下，但这（上面提到的）更好 - ＆gt;

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

我的回答是：

static String leadingZeros(int num, int digitSize) {
    //test for capacity being too small.

    if (digitSize < String.valueOf(num).length()) {
        return "Error : you number  " + num + " is higher than the decimal system specified capacity of " + digitSize + " zeros.";

        //test for capacity will exactly hold the number.
    } else if (digitSize == String.valueOf(num).length()) {
        return String.valueOf(num);

        //else do something here to calculate if the digitSize will over flow the StringBuilder buffer java.lang.OutOfMemoryError 

        //else calculate and return string
    } else {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < digitSize; i++) {
            sb.append("0");
        }
        sb.append(String.valueOf(num));
        return sb.substring(sb.length() - digitSize, sb.length());
    }
}

Answer 20

我用过这个：

DecimalFormat numFormat = new DecimalFormat("00000");
System.out.println("Code format: "+numFormat.format(123));

结果：00123

我希望你觉得它很有用！

左边填充一个带零的字符串

20 个答案: