题
有没有一些简单的方法可以在Java中填充字符串?
似乎应该在一些类似 StringUtil 的 API 中,但我找不到任何可以做到这一点的东西。
其他提示
从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*
填充到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
*********
在番石榴时,这是很容易:
Strings.padStart("string", 10, ' ');
Strings.padEnd("string", 10, ' ');
<强>要简单的:强>
的值应为一个字符串。将其转换为字符串,如果它不是。像"" + 123
或Integer.toString(123)
// let's assume value holds the String we want to pad
String value = "123";
从值长度字符的索引子串开始直到衬垫的端长度:
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"
看一看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();
}
此外阿帕奇百科全书,也参见String.format
这应该是能够照顾简单填充的(例如,用空格)。
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...
这花了我一些时间来弄清楚。 的真正关键是要读取格式化文档。
// 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);
我知道这个线程是一种古老和原始的问题是一个简单的解决方案,但如果它应该是非常快,你应该使用一个字符数组。
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);
将防止某人的内部缓冲器的生长。
下面是另一种垫向右:
// 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-------";
可以通过保持填充数据,而不是每次重建它减小每个呼叫的开销:
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(...)
方法。在这种情况下做隐藏填充的调整在该方法,而不是在构造。
(提示:对于额外的信用,使线程安全的; - )
可以使用内置的StringBuilder追加()和插入()方法 对于可变字符串长度的填充:
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());
此工作的:
"".format("%1$-" + 9 + "s", "XXX").replaceAll(" ", "0")
这将填补你的字符串XXX多达9个字符用空格。之后,所有的空格,都会用0来代替你可以改变空格和0到任何你想要的......
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 "";
}
让我为某些情况留下答案,在连接到另一个字符串之前,您需要提供左/右填充(或前缀/后缀字符串或空格),并且您不想测试长度或任何 if 条件。
与所选答案相同,我更喜欢 StringUtils
Apache Commons 的但使用这种方式:
StringUtils.defaultString(StringUtils.leftPad(myString, 1))
解释:
myString
:我输入的字符串可以为空StringUtils.leftPad(myString, 1)
:如果字符串为 null,则此语句也会返回 null- 然后使用
defaultString
给出空字符串以防止连接 null
@ck'沙 @马龙塔拉克的答案是唯一使用 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
java.util.Formatter
将做左右填充。无需奇第三方的依赖(你想增加他们的东西这么简单)。
[我已经离开了细节,发这个帖子“社区维基”,因为它是不是我有需要。
使用该功能。
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
很多人有一些非常有趣的技术,但我想保持它的简单,所以我去这样的:
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();
}
由于Java 11,String.repeat(INT)可用于左/右垫给定的字符串。
System.out.println("*".repeat(5)+"apple");
System.out.println("apple"+"*".repeat(5));
输出:
*****apple
apple*****
一个简单的解决方案的没有任何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();
}
爪哇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"
全部 细绳 操作通常需要 非常高效 - 特别是当您正在处理大量数据时。我想要一些快速且灵活的东西,类似于您在 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[] 上完成所有操作,而不必继续在格式之间进行转换 - 在幕后,字符串存储为 char[]。如果这些操作包含在 String 类本身中,那么效率将提高一倍 - 速度和内存方面。
如何使用递归? 下面给出的解决方案是与所有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);
}
}
注意强>:该解决方案将追加填充,具有小调整可以前缀垫值
一个简单的解决办法是:
package nl;
public class Padder {
public static void main(String[] args) {
String s = "123" ;
System.out.println("#"+(" " + s).substring(s.length())+"#");
}
}
这是如何
的字符串是“你好”和所需的填充是15用“0”左垫
String ax="Hello";
while(ax.length() < 15) ax="0"+ax;