如何在Java中填充string？

有没有一些简单的方法来填充Java中的string？

似乎应该在一些类似StringUtil的API中，但我找不到任何这样做。

Answer 1

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

编辑：正如其他人在这个答案中提到和演示，JDK中的String.format()和Formatter类是更好的select。 在公共代码上使用它们。

Answer 2

从Java 1.5开始，可以使用String.format()来左/右填充给定的string。

 public static String padRight(String s, int n) { return String.format("%1$-" + n + "s", s); } public static String padLeft(String s, int n) { return String.format("%1$" + n + "s", s); } ... public static void main(String args[]) throws Exception { System.out.println(padRight("Howto", 20) + "*"); System.out.println(padLeft("Howto", 20) + "*"); } /* output : Howto * Howto* */ 

Answer 3

填充至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(' ', '*'); 

输出的长度与密码string的长度相同：

  secret123 ********* 

Answer 4

在番石榴 ，这很容易：

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

Answer 5

简单一点：

值应该是一个string。 将其转换为string，如果不是。 像"" + 123或Integer.toString(123)

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

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

 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" 

Answer 6

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

但algorithm是非常简单的（填充大小字符）：

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

Answer 7

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

Answer 8

 public static String LPad(String str, Integer length, char car) { return str + String.format("%" + (length - str.length()) + "s", "") .replace(" ", String.valueOf(car)); } public static String RPad(String str, Integer length, char car) { return String.format("%" + (length - str.length()) + "s", "") .replace(" ", String.valueOf(car)) + str; } LPad("Hi", 10, 'R') //gives "RRRRRRRRHi" RPad("Hi", 10, 'R') //gives "HiRRRRRRRR" RPad("Hi", 10, ' ') //gives "Hi " //etc... 

Answer 9

这花了我一点时间才弄清楚。 真正的关键是阅读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); 

Answer 10

我知道这个线程是有点老，原来的问题是一个简单的解决scheme，但如果它应该是非常快，你应该使用一个字符数组。

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

格式化程序解决scheme不是最佳的。 只是build立格式string创build2个新的string。

apache的解决scheme可以通过初始化sb的目标大小来改进，以便在下面进行replace

 StringBuffer padded = new StringBuffer(str); 

同

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

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

Answer 11

这是另一种方法来填补右边：

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

Answer 12

您可以通过保留填充数据来减less每次通话的开销，而不是每次重build：

 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(...)方法的参数。 在这种情况下，请在该方法而不是在构造函数中调整隐藏的填充。

（提示：为了获得额外的信用，请使其线程安全！;-)

Answer 13

您可以使用内置的StringBuilder append（）和insert（）方法来填充可变string长度：

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

Answer 14

这工作：

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

它会填充您的stringXXX最多9个字符与空格。 之后，所有空白空间将被replace为0.您可以将空白和0更改为任何你想要的…

Answer 15

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

Answer 16

让我留下一些你需要给左/右填充（或前缀/后缀string或空格）的情况下，你连接到另一个string，你不想testing长度或任何条件的答案。

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

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

说明：

• myString ：我input的string，可以是null
• StringUtils.leftPad(myString, 1) ：如果string为null，那么这个语句也会返回null
• 然后使用defaultString给予空string以防止连接null

Answer 17

java.util.Formatter会左右填充。 不需要奇怪的第三方依赖（你想添加他们的东西这么微不足道）。

[我遗漏了细节，并发表了这个post'社区wiki'，因为这不是我所需要的。]

Answer 18

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

简单的testing方法：

 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 

Answer 19

许多人有一些非常有趣的技术，但我喜欢保持简单，所以我走这个：

 public static String padRight(String s, int n, char padding){ String pad = ""; for(int i = 0; i < n; i++){ pad += padding; } return s + pad; } public static String padLeft(String s, int n, char padding) { String pad = ""; for(int i = 0; i < n; i++){ pad += padding; } return pad + s; } public static String pad(String s, int n, char padding){ return padLeft(padRight(s,n, padding),n,padding); } 

Answer 20

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

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

Answer 21

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" 

Answer 22

所有string操作通常都需要非常高效 – 特别是在处理大量数据时。 我想要一些快速而灵活的东西，类似于你将在plsql pad命令中得到的东西。 另外，我不想仅仅为了一件小事就包括一个巨大的库。 有了这些考虑，这些解决scheme都不令人满意。 这是我提出的解决scheme，有最好的基准testing结果，如果有人可以改进，请添加您的评论。

 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类本身中，那么效率将会提高一倍 – 速度和内存都是明智的。

Answer 23

在Dzone上find了这个

用零填充：

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

Answer 24

一个简单的解决scheme是：

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

Answer 25

这怎么样

string是“你好”，所需的填充是15左边的“0”垫

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