有没有一些简单的方法可以在 Java 中填充字符串？
似乎应该在一些类似 StringUtil 的 API 中，但我找不到任何这样做的东西。
pvgoddijn
问问题
659427 次
30 回答
691
从 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*
于 2008-12-24T18:21:54.493 回答
275
填充到 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
*********
于 2011-05-31T09:13:08.153 回答
88
在Guava中，这很容易：
Strings.padStart("string", 10, ' ');
Strings.padEnd("string", 10, ' ');
于 2011-09-21T15:56:44.543 回答
39
一些简单的事情：
该值应该是一个字符串。如果不是，将其转换为字符串。喜欢"" + 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"
于 2013-09-02T08:29:41.523 回答
26
看看org.apache.commons.lang.StringUtils#rightPad(String str, int size, char padChar)。
但是算法非常简单（填充到大小字符）：
public String pad(String str, int size, char padChar)
{
StringBuilder padded = new StringBuilder(str);
while (padded.length() < size)
{
padded.append(padChar);
}
return padded.toString();
}
于 2008-12-23T09:24:38.683 回答
22
除了 Apache Commons，还可以查看String.format哪些应该能够处理简单的填充（例如，使用空格）。
于 2008-12-23T09:24:20.493 回答
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...
于 2012-02-09T17:22:06.493 回答
15
从 Java 11 开始，String.repeat(int) 可用于向左/向右填充给定的字符串。
System.out.println("*".repeat(5)+"apple");
System.out.println("apple"+"*".repeat(5));
输出：
*****apple
apple*****
于 2018-11-24T14:50:15.337 回答
7
我知道这个线程有点旧，最初的问题是一个简单的解决方案，但如果它应该非常快，你应该使用一个 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);
会阻止某人的内部缓冲区增长。
于 2010-10-28T14:34:48.523 回答
6
我花了一点时间才弄清楚。真正的关键是阅读 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);
于 2010-10-29T20:58:09.183 回答
6
于 2017-10-26T19:20:30.223 回答
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-------";
于 2011-09-21T15:45:45.857 回答
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(...)方法的参数。在这种情况下，在该方法中而不是在构造函数中调整隐藏的填充。
（提示：为了额外的功劳，让它线程安全！;-)
于 2008-12-23T14:25:42.257 回答
2
java.util.Formatter将做左右填充。不需要奇怪的第三方依赖项（您是否想为如此琐碎的事情添加它们）。
[我省略了细节并将这篇文章设为“社区维基”，因为这不是我需要的。]
于 2008-12-23T14:58:42.737 回答
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());
于 2010-08-24T10:55:49.627 回答
2
这有效：
"".format("%1$-" + 9 + "s", "XXX").replaceAll(" ", "0")
它将用空格填充您的 String XXX 最多 9 个字符。之后，所有空格都将替换为 0。您可以将空格和 0 更改为您想要的任何内容...
于 2011-05-11T14:30:17.743 回答
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 "";
}
于 2011-08-24T17:36:51.160 回答
2
很多人都有一些非常有趣的技术，但我喜欢保持简单，所以我选择了这个：
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();
}
于 2015-08-28T16:58:55.157 回答
2
对于某些需要在连接到另一个字符串之前提供左/右填充（或前缀/后缀字符串或空格）并且您不想测试长度或任何 if 条件的情况，让我留下一个答案。
与所选答案相同，我更喜欢StringUtilsApache Commons 但使用这种方式：
StringUtils.defaultString(StringUtils.leftPad(myString, 1))
解释：
myString: 我输入的字符串，可以为空StringUtils.leftPad(myString, 1): 如果 string 为 null，则此语句也将返回 null- 然后使用
defaultString给空字符串以防止连接 null
于 2016-08-11T05:09:33.957 回答
2
@ck和@Marlon Tarak的答案是唯一使用 a 的答案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
于 2017-07-11T20:39:46.400 回答
2
所有字符串操作通常都需要非常高效——尤其是在处理大量数据时。我想要一些快速灵活的东西，类似于你在 plsql pad 命令中得到的东西。另外，我不想只为一件小事包含一个巨大的库。考虑到这些考虑，这些解决方案中没有一个是令人满意的。这是我提出的解决方案，具有最好的基准测试结果，如果有人可以改进它，请添加您的评论。
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() 调用的，结果可以用 new String((char[])result) 转换为 String。这样做的原因是，如果您应用多个操作，您可以在 char[] 上执行所有操作，而不是继续在格式之间进行转换 - 在幕后，String 存储为 char[]。如果这些操作包含在 String 类本身中，效率会提高一倍 - 速度和内存方面。
于 2017-09-14T07:25:35.407 回答
2
使用此功能。
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
于 2017-11-30T08:06:18.967 回答
2
这是一个高效的实用程序类，用于Java 中的left pad、right pad、center pad和零填充字符串。
package com.example;
/**
* Utility class for left pad, right pad, center pad and zero fill.
*/
public final class StringPadding {
public static String left(String string, int length, char fill) {
if (string.length() < length) {
char[] chars = string.toCharArray();
char[] output = new char[length];
int delta = length - chars.length;
for (int i = 0; i < length; i++) {
if (i < delta) {
output[i] = fill;
} else {
output[i] = chars[i - delta];
}
}
return new String(output);
}
return string;
}
public static String right(String string, int length, char fill) {
if (string.length() < length) {
char[] chars = string.toCharArray();
char[] output = new char[length];
for (int i = 0; i < length; i++) {
if (i < chars.length) {
output[i] = chars[i];
} else {
output[i] = fill;
}
}
return new String(output);
}
return string;
}
public static String center(String string, int length, char fill) {
if (string.length() < length) {
char[] chars = string.toCharArray();
int delta = length - chars.length;
int a = (delta % 2 == 0) ? delta / 2 : delta / 2 + 1;
int b = a + chars.length;
char[] output = new char[length];
for (int i = 0; i < length; i++) {
if (i < a) {
output[i] = fill;
} else if (i < b) {
output[i] = chars[i - a];
} else {
output[i] = fill;
}
}
return new String(output);
}
return string;
}
public static String zerofill(String string, int length) {
return left(string, length, '0');
}
private StringPadding() {
}
/**
* For tests!
*/
public static void main(String[] args) {
String string = "123";
char blank = ' ';
System.out.println("left pad: [" + StringPadding.left(string, 10, blank) + "]");
System.out.println("right pad: [" + StringPadding.right(string, 10, blank) + "]");
System.out.println("center pad: [" + StringPadding.center(string, 10, blank) + "]");
System.out.println("zero fill: [" + StringPadding.zerofill(string, 10) + "]");
}
}
这是输出：
left pad: [ 123]
right pad: [123 ]
center pad: [ 123 ]
zero fill: [0000000123]
于 2020-07-25T17:12:44.150 回答
1
Java oneliners，没有花哨的库。
// 6 characters padding example
String pad = "******";
// testcases for 0, 4, 8 characters
String input = "" | "abcd" | "abcdefgh"
垫左，不要限制
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"
垫右，限制垫长度
result = (input + pad).substring(0, pad.length());
results: "******" | "abcd**" | "abcdef"
于 2017-08-31T21:49:38.423 回答
1
使用递归怎么样？下面给出的解决方案与所有 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);
}
}
注意：此解决方案将附加填充，稍加调整即可为填充值添加前缀。
于 2019-08-13T18:11:37.573 回答
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();
}
于 2017-05-06T04:17:57.723 回答
0
对于那些拥有很长字符串的人来说，这是一个并行版本:-)
int width = 100;
String s = "129018";
CharSequence padded = IntStream.range(0,width)
.parallel()
.map(i->i-(width-s.length()))
.map(i->i<0 ? '0' :s.charAt(i))
.collect(StringBuilder::new, (sb,c)-> sb.append((char)c), (sb1,sb2)->sb1.append(sb2));
于 2019-09-19T18:58:20.360 回答
-1
一个简单的解决方案是：
package nl;
public class Padder {
public static void main(String[] args) {
String s = "123" ;
System.out.println("#"+(" " + s).substring(s.length())+"#");
}
}
于 2012-01-19T12:24:53.450 回答
-2
这怎么样
字符串为“hello”，所需的填充为 15，左填充为“0”
String ax="Hello";
while(ax.length() < 15) ax="0"+ax;
于 2013-03-28T11:53:39.633 回答