如何在Java中填充字符串？

时间：2008-12-23 09:15:24

标签： java string padding

是否有一些简单的方法可以在Java中填充字符串？

看起来像某些类似于StringUtil的API，但我找不到任何可以做到这一点的东西。

31 个答案:

答案 0 :(得分：583)

从Java 1.5开始，String.format()可用于左/右填充给定字符串。

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

输出是：

Howto               *
               Howto*

答案 1 :(得分：240)

填充到10个字符：

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

输出：

  *******foo
  bar*******
  longer*than*10*chars

显示密码字符'*'：

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

输出与密码字符串的长度相同：

  secret123
  *********

答案 2 :(得分：166)

Apache StringUtils有几种方法：leftPad，rightPad，center和repeat。

但请注意 - 正如其他人在this answer中提到并演示的那样 - String.format()和JDK中的Formatter类是更好的选择。在公共代码上使用它们。

答案 3 :(得分：86)

在Guava中，这很简单：

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

答案 4 :(得分：30)

简单的事情：

该值应为字符串。将其转换为字符串，如果不是。与"" + 123或Integer.toString(123)

相同 
// let's assume value holds the String we want to pad
String value = "123";

子字符串从值长度char索引开始直到填充的结束长度：

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

// now padded is "00000123"

更精确

右键：

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

// now padded is "123DEFGH"
垫左：

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

// now padded is "ABCDE123"

答案 5 :(得分：22)

查看org.apache.commons.lang.StringUtils#rightPad(String str, int size, char padChar)。

但算法很简单（填充到大小字符）：

public String pad(String str, int size, char padChar)
{
  StringBuffer padded = new StringBuffer(str);
  while (padded.length() < size)
  {
    padded.append(padChar);
  }
  return padded.toString();
}

答案 6 :(得分：21)

除了Apache Commons之外，还可以看String.format，它应该能够处理简单的填充（例如空格）。

答案 7 :(得分：16)

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...

答案 8 :(得分：7)

我花了一点时间才弄明白。 真正的关键是阅读Formatter文档。

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

答案 9 :(得分：6)

我知道这个帖子有点陈旧，原来的问题是一个简单的解决方案，但如果它应该非常快，你应该使用一个char数组。

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

格式化程序解决方案不是最佳的。只需构建格式字符串就可以创建2个新字符串。

apache的解决方案可以通过初始化目标大小的sb来改进，以便替换

StringBuffer padded = new StringBuffer(str);

带

StringBuffer padded = new StringBuffer(pad); 
padded.append(value);

会阻止sb的内部缓冲区增长。

答案 10 :(得分：5)

这是另一种向右填充的方法：

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

答案 11 :(得分：4)

您可以通过保留填充数据来减少每次调用的开销，而不是每次都重建它：

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

}

作为替代方法，您可以将结果长度设为pad(...)方法的参数。在这种情况下，请在该方法中而不是在构造函数中调整隐藏填充。

（提示：为了额外的功劳，让它线程安全！; - ）

答案 12 :(得分：3)

在Dzone

上找到了这个

用零填充：

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

答案 13 :(得分：2)

这有效：

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

它将使用空格填充你的String XXX最多9个Chars。之后，所有空格将被替换为0.您可以将空格和0更改为您想要的任何内容...

答案 14 :(得分：2)

@ck和@Marlon Tarak的答案是唯一使用char[]的答案，对于每秒都有几次调用填充方法的应用程序是最好的方法。但是，他们没有利用任何阵列操作优化，并且根据我的口味略微改写;这可以通过完全没有循环来完成。

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

简单的测试方法：

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

输出：

012345678901234567890123456789
cats                          
                          cats
                cats
cats$$$$$$$$$$$$$$$$$$$$$$$$$$
too long for your own good, buddy

答案 15 :(得分：2)

让我留下你需要在连接到另一个字符串之前给出左/右填充（或前缀/后缀字符串或空格）并且你不想测试长度或任何if条件的情况的答案。 / p>

与所选答案相同，我更喜欢Apache Commons的StringUtils，但使用这种方式：

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

说明：

  • myString：我输入的字符串可以为null
  • StringUtils.leftPad(myString, 1)：如果string为null，则此语句也将返回null
  • 然后使用defaultString提供空字符串以防止连接null

答案 16 :(得分：2)

你可以使用内置的StringBuilder append（）和insert（）方法， 用于填充可变字符串长度：

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

例如：

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

答案 17 :(得分：2)

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

答案 18 :(得分：1)

java.util.Formatter将执行左右填充。不需要奇怪的第三方依赖（你想要将它们添加到如此微不足道的东西中）。

[我已经省略了细节并将这篇文章发布为'社区维基'，因为它不是我需要的。]

答案 19 :(得分：1)

很多人都有一些非常有趣的技巧，但我喜欢保持简单，所以我选择这个：

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

答案 20 :(得分：1)

使用此功能。

private String leftPadding(String word, int length, char ch) {
   return (length > word.length()) ? leftPadding(ch + word, length, ch) : word;
}

怎么用？ 

leftPadding(month, 2, '0');

输出： 01 02 03 04 .. 11 12

答案 21 :(得分：1)

从Java 11开始，String.repeat（int）可用于左/右填充给定的字符串。

$('textarea').html(childInfoString);

输出：

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

答案 22 :(得分：1)

此实用程序类对左键盘和零填充字符串很有用。我希望它能对某人有所帮助！

package your.package.name;

/**
 * Utility class for left pad and zero fill of Strings.
 * 
 */
public class LeftPad {

    public static String lpad(String string, int length, char fill) {
        return new String(lpad(string.toCharArray(), length, fill));
    }

    public static String zerofill(String string, int length) {
        return new String(zerofill(string.toCharArray(), length));
    }

    private static char[] lpad(char[] chars, int length, char fill) {

        int delta = 0;
        int limit = 0;

        if (length > chars.length) {
            delta = length - chars.length;
            limit = length;
        } else {
            delta = 0;
            limit = chars.length;
        }

        char[] output = new char[chars.length + delta];
        for (int i = 0; i < limit; i++) {
            if (i < delta) {
                output[i] = fill;
            } else {
                output[i] = chars[i - delta];
            }
        }
        return output;
    }

    private static char[] zerofill(char[] chars, int length) {
        return lpad(chars, length, '0');
    }

    /**
     * For tests!
     */
    public static void main(String[] args) {

        String string = "123";
        char pad = ' ';

        System.out.println("left pad blank: " + string);
        System.out.println("Result: [" + LeftPad.lpad(string, 10, pad) + "]");

        System.out.println();
        System.out.println("zero fill: " + string);
        System.out.println("Result: [" + LeftPad.zerofill(string, 10) + "]");
    }
}

这是输出：

left pad blank: 123
Result: [       123]

zero fill: 123
Result: [0000000123]

答案 23 :(得分：0)

没有任何API 的简单解决方案如下：

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

答案 24 :(得分：0)

Java oneliners，没有花哨的库。 

[SentOn]

垫左，不限

// 6 characters padding example
String pad = "******";
// testcases for 0, 4, 8 characters
String input = "" | "abcd" | "abcdefgh"

Pad Pad，不要限制

result = pad.substring(Math.min(input.length(),pad.length())) + input;
results: "******" | "**abcd" | "abcdefgh"

填充左侧，限制填充长度

result = input + pad.substring(Math.min(input.length(),pad.length()));
results: "******" | "abcd**" | "abcdefgh"

垫右，限制垫长度

result = (pad + input).substring(input.length(), input.length() + pad.length());
results: "******" | "**abcd" | "cdefgh"

答案 25 :(得分：0)

所有字符串操作通常需要非常高效 - 尤其是在处理大量数据时。我想要一些快速而灵活的东西，类似于你在plsql pad命令中得到的东西。此外，我不想只为一件小事包含一个巨大的lib。出于这些考虑，这些解决方案都不令人满意。这是我提出的解决方案，它有最好的基准测试结果，如果有人可以改进，请添加你的评论。

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;
    }
}
  • 注意它是用String.toCharArray（）调用的，结果可以用新的String（（char []）结果转换为String）。原因是，如果你应用多个操作，你可以在char []上完成所有操作，而不是继续在格式之间进行转换 - 在幕后，String存储为char []。如果这些操作包含在String类本身中，它的效率将提高两倍 - 速度和内存。

答案 26 :(得分：0)

如何使用递归？ 下面给出的解决方案与所有JDK版本兼容，不需要外部库：） 

private static String addPadding(final String str, final int desiredLength, final String padBy) {
        String result = str;
        if (str.length() >= desiredLength) {
            return result;
        } else {
            result += padBy;
            return addPadding(result, desiredLength, padBy);
        }
    }

注意：此解决方案将添加填充，只需稍加调整即可为填充值添加前缀。

答案 27 :(得分：0)

这是针对那些字符串很长的人的平行版本：-）

OnStartup()

答案 28 :(得分：0)

番石榴中的填充示例：

Apache Commons中的填充示例：

JDK中的填充示例：

答案 29 :(得分：-1)

一个简单的解决方案是：

package nl;
public class Padder {
    public static void main(String[] args) {
        String s = "123" ;
        System.out.println("#"+("     " + s).substring(s.length())+"#");
    }
}

答案 30 :(得分：-2)

这是怎么回事？

字符串是“hello”，所需的填充是15，左边的“0”填充

String ax="Hello";
while(ax.length() < 15) ax="0"+ax;
相关问题
最新问题