Слева заполнение строки нулями [дубликат]

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

второй параметр-это желаемая длина вывода

"0" - это заполнения char

это будет pad оставил любую строку на общую ширину 10, не беспокоясь об ошибках разбора:

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

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

Если вы хотите, чтобы pad право:

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"  

благо это ответ Хачика заключается в том, что это не использует целое число.parseInt, который может вызвать исключение (например, если число, которое вы хотите заполнить, слишком велико, например 12147483647). Недостатком является то, что если то, что вы заполняете, уже является int, то вам придется преобразовать его в строку и обратно, что нежелательно.

Итак, если вы точно знаете, что это int, ответ Хачика отлично работает. Если нет, то это возможная стратегия.

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

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

вы можете использовать Apache commons StringUtils

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

http://commons.apache.org/lang/api-2.3/org/apache/commons/lang/StringUtils.html

для форматирования строк использовать

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

где первый аргумент - это строка, которая должна быть отформатирована, второй аргумент-это длина желаемой выходной длины, а третий аргумент-это символ, с которым строка должна быть дополнена.

используйте ссылку для загрузки jar http://commons.apache.org/proper/commons-lang/download_lang.cgi

Если вам нужна производительность и вы знаете максимальный размер строки, используйте это:

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

имейте в виду максимальный размер строки. Если он больше, то размер StringBuffer, вы получите java.lang.StringIndexOutOfBoundsException.

старый вопрос, но у меня тоже есть два способа.

---

для фиксированной (предопределенной) длины:

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

использовать 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"  

вот еще один подход:

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

вот мое решение:

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

правая прокладка с длиной починки-10: Строка.формат ("%1$ - 10s", " abc") Левая прокладка с фиксированной длиной-10: Строка.формат ("%1$10s","abc")

решение Сатиша очень хорошо среди ожидаемых ответов. Я хотел сделать его более общим, добавив переменную n в строку формата вместо 10 символов.

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

Это будет работать в большинстве ситуаций

на основе @Haroldo Macêdo это!--5-->, Я создал метод в моем таможни 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");

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

просто спросил об этом в интервью........

мой ответ ниже, но это (упомянуто выше) намного лучше->

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

проверьте мой код, который будет работать для целого числа и строки.

предположим, что наше первое число-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")+number;
    }        
    System.out.println(resultString);

вот решение, основанное на строку.формат, который будет работать для строк и подходит для переменной длины.

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'

Я предпочитаю этот код:

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

я использовал этот:

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

результат: 00123

Я надеюсь, что вы найдете ее полезной!