Tukukkk

Since Java 1.5, String.format() can be used to left/right pad a given string.

public static String padRight(String s, int n) {

     return String.format("%-" + n + "s", s);  

}



public static String padLeft(String s, int n) {

    return String.format("%" + n + "s", s);  

}



...



public static void main(String args) throws Exception {

 System.out.println(padRight("Howto", 20) + "*");

 System.out.println(padLeft("Howto", 20) + "*");

}

And the output is:

Howto               *

               Howto*

Padding to 10 characters:

String.format("%10s", "foo").replace(' ', '*');

String.format("%-10s", "bar").replace(' ', '*');

String.format("%10s", "longer than 10 chars").replace(' ', '*');

output:

  *******foo

  bar*******

  longer*than*10*chars

Display '*' for characters of password:

String password = "secret123";

String padded = String.format("%"+password.length()+"s", "").replace(' ', '*');

output has the same length as the password string:

  secret123

  *********

In Guava, this is easy:

Strings.padStart("string", 10, ' ');

Strings.padEnd("string", 10, ' ');

Something simple:

The value should be a string. convert it to string, if it's not. Like "" + 123 or Integer.toString(123)

// let's assume value holds the String we want to pad

String value = "123";

Substring start from the value length char index until end length of padded:

String padded="00000000".substring(value.length()) + value;



// now padded is "00000123"

More precise

pad right:

String padded = value + ("ABCDEFGH".substring(value.length())); 



// now padded is "123DEFGH"

pad left:

String padString = "ABCDEFGH";

String padded = (padString.substring(0, padString.length() - value.length())) + value;



// now padded is "ABCDE123"

Have a look at org.apache.commons.lang.StringUtils#rightPad(String str, int size, char padChar).

But the algorithm is very simple (pad right up to size chars):

public String pad(String str, int size, char padChar)

{

  StringBuffer padded = new StringBuffer(str);

  while (padded.length() < size)

  {

    padded.append(padChar);

  }

  return padded.toString();

}

Besides Apache Commons, also see String.format which should be able to take care of simple padding (e.g. with spaces).

public static String LPad(String str, Integer length, char car) {

  return (str + String.format("%" + length + "s", "").replace(" ", String.valueOf(car))).substring(0, length);

}



public static String RPad(String str, Integer length, char car) {

  return (String.format("%" + length + "s", "").replace(" ", String.valueOf(car)) + str).substring(str.length(), length + str.length());

}



LPad("Hi", 10, 'R') //gives "RRRRRRRRHi"

RPad("Hi", 10, 'R') //gives "HiRRRRRRRR"

RPad("Hi", 10, ' ') //gives "Hi        "

RPad("Hi", 1, ' ')  //gives "H"

//etc...

This took me a little while to figure out.
The real key is to read that Formatter documentation.

// Get your data from wherever.

final byte data = getData();

// Get the digest engine.

final MessageDigest md5= MessageDigest.getInstance("MD5");

// Send your data through it.

md5.update(data);

// Parse the data as a positive BigInteger.

final BigInteger digest = new BigInteger(1,md5.digest());

// Pad the digest with blanks, 32 wide.

String hex = String.format(

    // See: http://download.oracle.com/javase/1.5.0/docs/api/java/util/Formatter.html

    // Format: %[argument_index$][flags][width]conversion

    // Conversion: 'x', 'X'  integral    The result is formatted as a hexadecimal integer

    "%1$32x",

    digest

);

// Replace the blank padding with 0s.

hex = hex.replace(" ","0");

System.out.println(hex);

i know this thread is kind of old and the original question was for an easy solution but if it's supposed to be really fast, you should use a char array.

public static String pad(String str, int size, char padChar)

{

    if (str.length() < size)

    {

        char temp = new char[size];

        int i = 0;



        while (i < str.length())

        {

            temp[i] = str.charAt(i);

            i++;

        }



        while (i < size)

        {

            temp[i] = padChar;

            i++;

        }



        str = new String(temp);

    }



    return str;

}

the formatter solution is not optimal. just building the format string creates 2 new strings.

apache's solution can be improved by initializing the sb with the target size so replacing below

StringBuffer padded = new StringBuffer(str); 

with

StringBuffer padded = new StringBuffer(pad); 

padded.append(value);

would prevent the sb's internal buffer from growing.

Here is another way to pad to the right:

// put the number of spaces, or any character you like, in your paddedString



String paddedString = "--------------------";



String myStringToBePadded = "I like donuts";



myStringToBePadded = myStringToBePadded + paddedString.substring(myStringToBePadded.length());



//result:

myStringToBePadded = "I like donuts-------";

You can reduce the per-call overhead by retaining the padding data, rather than rebuilding it every time:

public class RightPadder {



    private int length;

    private String padding;



    public RightPadder(int length, String pad) {

        this.length = length;

        StringBuilder sb = new StringBuilder(pad);

        while (sb.length() < length) {

            sb.append(sb);

        }

        padding = sb.toString();

   }



    public String pad(String s) {

        return (s.length() < length ? s + padding : s).substring(0, length);

    }



}

As an alternative, you can make the result length a parameter to the pad(...) method. In that case do the adjustment of the hidden padding in that method instead of in the constructor.

(Hint: For extra credit, make it thread-safe! ;-)

you can use the built in StringBuilder append() and insert() methods,
for padding of variable string lengths:

AbstractStringBuilder append(CharSequence s, int start, int end) ;

For Example:

private static final String  MAX_STRING = "                    "; //20 spaces



    Set<StringBuilder> set= new HashSet<StringBuilder>();

    set.add(new StringBuilder("12345678"));

    set.add(new StringBuilder("123456789"));

    set.add(new StringBuilder("1234567811"));

    set.add(new StringBuilder("12345678123"));

    set.add(new StringBuilder("1234567812234"));

    set.add(new StringBuilder("1234567812222"));

    set.add(new StringBuilder("12345678122334"));



    for(StringBuilder padMe: set)

        padMe.append(MAX_STRING, padMe.length(), MAX_STRING.length());

This works:

"".format("%1$-" + 9 + "s", "XXX").replaceAll(" ", "0")

It will fill your String XXX up to 9 Chars with a whitespace. After that all Whitespaces will be replaced with a 0. You can change the whitespace and the 0 to whatever you want...

public static String padLeft(String in, int size, char padChar) {                

    if (in.length() <= size) {

        char temp = new char[size];

        /* Llenado Array con el padChar*/

        for(int i =0;i<size;i++){

            temp[i]= padChar;

        }

        int posIniTemp = size-in.length();

        for(int i=0;i<in.length();i++){

            temp[posIniTemp]=in.charAt(i);

            posIniTemp++;

        }            

        return new String(temp);

    }

    return "";

}

Let's me leave an answer for some cases that you need to give left/right padding (or prefix/suffix string or spaces) before you concatenate to another string and you don't want to test length or any if condition.

The same to the selected answer, I would prefer the StringUtils of Apache Commons but using this way:

StringUtils.defaultString(StringUtils.leftPad(myString, 1))

Explain:

• 
  myString: the string I input, can be null


• 
  StringUtils.leftPad(myString, 1): if string is null, this statement would return null too


• then use defaultString to give empty string to prevent concatenate null

Found this on Dzone

Pad with zeros:

String.format("|%020d|", 93); // prints: |00000000000000000093|

java.util.Formatter will do left and right padding. No need for odd third party dependencies (would you want to add them for something so trivial).

[I've left out the details and made this post 'community wiki' as it is not something I have a need for.]

@ck's and @Marlon Tarak's answers are the only ones to use a char, which for applications that have several calls to padding methods per second is the best approach. However, they don't take advantage of any array manipulation optimizations and are a little overwritten for my taste; this can be done with no loops at all.

public static String pad(String source, char fill, int length, boolean right){

    if(source.length() > length) return source;

    char out = new char[length];

    if(right){

        System.arraycopy(source.toCharArray(), 0, out, 0, source.length());

        Arrays.fill(out, source.length(), length, fill);

    }else{

        int sourceOffset = length - source.length();

        System.arraycopy(source.toCharArray(), 0, out, sourceOffset, source.length());

        Arrays.fill(out, 0, sourceOffset, fill);

    }

    return new String(out);

}

Simple test method:

public static void main(String... args){

    System.out.println("012345678901234567890123456789");

    System.out.println(pad("cats", ' ', 30, true));

    System.out.println(pad("cats", ' ', 30, false));

    System.out.println(pad("cats", ' ', 20, false));

    System.out.println(pad("cats", '$', 30, true));

    System.out.println(pad("too long for your own good, buddy", '#', 30, true));

}

Outputs:

012345678901234567890123456789

cats                          

                          cats

                cats

cats$$$$$$$$$$$$$$$$$$$$$$$$$$

too long for your own good, buddy 

Use this function.

private String leftPadding(String word, int length, char ch) {

   return (length > word.length()) ? leftPadding(ch + word, length, ch) : word;

}

how to use?

leftPadding(month, 2, '0');

output:
01 02 03 04 .. 11 12

A lot of people have some very interesting techniques but I like to keep it simple so I go with this :

public static String padRight(String s, int n, char padding){

    StringBuilder builder = new StringBuilder(s.length() + n);

    builder.append(s);

    for(int i = 0; i < n; i++){

        builder.append(padding);

    }

    return builder.toString();

}



public static String padLeft(String s, int n,  char padding) {

    StringBuilder builder = new StringBuilder(s.length() + n);

    for(int i = 0; i < n; i++){

        builder.append(Character.toString(padding));

    }

    return builder.append(s).toString();

}



public static String pad(String s, int n, char padding){

    StringBuilder pad = new StringBuilder(s.length() + n * 2);

    StringBuilder value = new StringBuilder(n);

    for(int i = 0; i < n; i++){

        pad.append(padding);

    }

    return value.append(pad).append(s).append(pad).toString();

}

A simple solution without any API will be as follows:

public String pad(String num, int len){

    if(len-num.length() <=0) return num;

    StringBuffer sb = new StringBuffer();

    for(i=0; i<(len-num.length()); i++){

        sb.append("0");

    }

    sb.append(num);

    return sb.toString();

}

Java oneliners, no fancy library.

// 6 characters padding example

String pad = "******";

// testcases for 0, 4, 8 characters

String input = "" | "abcd" | "abcdefgh"

Pad Left, don't limit

result = pad.substring(Math.min(input.length(),pad.length())) + input;

results: "******" | "**abcd" | "abcdefgh"

Pad Right, don't limit

result = input + pad.substring(Math.min(input.length(),pad.length()));

results: "******" | "abcd**" | "abcdefgh"

Pad Left, limit to pad length

result = (pad + input).substring(input.length(), input.length() + pad.length());

results: "******" | "**abcd" | "cdefgh"

Pad Right, limit to pad length

result = (input + pad).substring(0, pad.length());

results: "******" | "abcd**" | "abcdef"

All string operation usually needs to be very efficient - especially if you are working with big sets of data. I wanted something that's fast and flexible, similar to what you will get in plsql pad command. Also, I don't want to include a huge lib for just one small thing. With these considerations none of these solutions were satisfactory. This is the solutions I came up with, that had the best bench-marking results, if anybody can improve on it, please add your comment.

public static char lpad(char pStringChar, int pTotalLength, char pPad) {

    if (pStringChar.length < pTotalLength) {

        char retChar = new char[pTotalLength];

        int padIdx = pTotalLength - pStringChar.length;

        Arrays.fill(retChar, 0, padIdx, pPad);

        System.arraycopy(pStringChar, 0, retChar, padIdx, pStringChar.length);

        return retChar;

    } else {

        return pStringChar;

    }

}

• note it is called with String.toCharArray() and the result can be converted to String with new String((char)result). The reason for this is, if you applying multiple operations you can do them all on char and not keep on converting between formats - behind the scenes, String is stored as char. If these operations were included in the String class itself, it would have been twice as efficient - speed and memory wise.

Since Java 11, String.repeat(int) can be used to left/right pad a given string.

System.out.println("*".repeat(5)+"apple");

System.out.println("apple"+"*".repeat(5));

Output:

*****apple

apple*****

A simple solution would be:

package nl;

public class Padder {

    public static void main(String args) {

        String s = "123" ;

        System.out.println("#"+("     " + s).substring(s.length())+"#");

    }

}

How is this

String is "hello" and required padding is 15 with "0" left pad

String ax="Hello";

while(ax.length() < 15) ax="0"+ax;