반응형
Java에서 문자열을 패딩하려면 어떻게 해야 하나요?
Java에서 Strings를 쉽게 패딩할 수 있는 방법이 있나요?
String Util과 비슷한 API에 있어야 할 것 같은데 이 기능을 하는 것을 찾을 수 없습니다.
Java 1.5 이후로는 특정 문자열을 왼쪽/오른쪽 패드에 사용할 수 있습니다.
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
*********
Apache에는 , 및 여러 가지 메서드가 있습니다.
단, 이 답변에서 언급 및 시연했듯이 다음과 같은 점에 유의하시기 바랍니다.String.format() 및FormatterJDK j j 。일반 코드보다 그것들을 사용하세요.
구아바에서는, 이것은 간단합니다.
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)
{
StringBuilder padded = new StringBuilder(str);
while (padded.length() < size)
{
padded.append(padChar);
}
return padded.toString();
}
Commons 에 Apache Commons도 하십시오.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...
Java 11 이후 String.repeat(int)를 사용하여 특정 문자열을 좌우로 패딩할 수 있습니다.
System.out.println("*".repeat(5)+"apple");
System.out.println("apple"+"*".repeat(5));
출력:
*****apple
apple*****
이 스레드는 오래된 것으로, 원래의 질문은 간단한 해결책이었지만, 만약 그것이 정말 빠르다면, 당신은 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);
내부 버퍼가 커지는 것을 막을 수 있습니다.
이걸 알아내는 데 시간이 좀 걸렸어요진짜 핵심은 그 포메터 문서를 읽는 것입니다.
// 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);
Dzone에서 찾았습니다.
0이 있는 패드:
String.format("|%020d|", 93); // prints: |00000000000000000093|
오른쪽에 패드를 다는 또 다른 방법은 다음과 같습니다.
// 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(...) 컨스트럭터가 아닌 그 한다.이 경우 컨스트럭터가 아닌 해당 메서드로 숨겨진 패딩을 조정합니다.
(힌트: 추가 크레딧은 스레드 세이프!;-)
java.util.Formatter좌우 패딩을 합니다.홀수 서드파티 의존관계는 불필요합니다(이러한 사소한 일에 의존관계를 추가하시겠습니까).
[자세한 내용은 생략하고 커뮤니티 위키로 만들었습니다]
built in String Builder 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());
이 방법은 다음과 같습니다.
"".format("%1$-" + 9 + "s", "XXX").replaceAll(" ", "0")
String 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 "";
}
다른 문자열에 연결하기 전에 왼쪽/오른쪽 패딩(또는 프리픽스/서픽스 문자열 또는 공백)을 제공해야 하는 경우에 대한 답변을 남겨두겠습니다.
선택된 답변과 마찬가지로, 저는 다음 답변이 더 좋습니다.StringUtils아파치 커먼즈
StringUtils.defaultString(StringUtils.leftPad(myString, 1))
설명:
myString수 null은 null입니다.StringUtils.leftPad(myString, 1): 늘인 이 "null" "null" "null" "null" "null" "null" "null"- 으로 ' '를 사용합니다.
defaultString
@ck와 @Marlon Tarak의 답변은 다음 명령어를 사용하는 유일한 사용자입니다.char[]1초당 패딩 메서드에 대한 콜이 여러 개 있는 어플리케이션에서는 이것이 최선의 접근법입니다.다만, 어레이 조작의 최적화를 이용하지 않고, 제 취향에 맞추어 약간 덮어쓰기 되어 있습니다.이 작업은 루프 없이 실시할 수 있습니다.
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
일반적으로 모든 문자열 작업은 매우 효율적일 필요가 있습니다. 특히 대용량 데이터 세트를 사용하는 경우에는 더욱 그렇습니다.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[] result)을 사용하여 String으로 변환할 수 있습니다.그 이유는 여러 작업을 적용하면 모든 작업을 char[]로 수행할 수 있고 형식 간 변환을 계속할 수 없기 때문입니다. 이 경우 String은 char[]로 저장됩니다.이러한 조작이 String 클래스 자체에 포함되어 있으면 속도와 메모리 효율이 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
많은 사람들이 매우 흥미로운 기술을 가지고 있지만, 저는 단순하게 하는 것을 좋아하기 때문에 다음과 같이 하겠습니다.
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에서 왼쪽 패드, 오른쪽 패드, 중앙 패드 및 문자열 제로 필을 위한 효율적인 유틸리티 클래스입니다.
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]
자바 온라인 사용자들, 화려한 도서관도 없고.
// 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"
재귀를 이용하는 건 어때?아래에 제시된 솔루션은 모든 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);
}
}
메모: 이 솔루션에서는 패딩을 추가합니다.조금만 수정하면 패드의 값을 앞에 붙일 수 있습니다.
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();
}
여기 스트링이 매우 긴 사용자를 위한 병렬 버전이 있습니다:-)
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));
간단한 해결책은 다음과 같습니다.
package nl;
public class Padder {
public static void main(String[] args) {
String s = "123" ;
System.out.println("#"+(" " + s).substring(s.length())+"#");
}
}
이거 어때요?
문자열은 "hello"이고 필수 패딩은 15이고 왼쪽 패드는 "0"입니다.
String ax="Hello";
while(ax.length() < 15) ax="0"+ax;
언급URL : https://stackoverflow.com/questions/388461/how-can-i-pad-a-string-in-java
반응형
'source' 카테고리의 다른 글
| Python에서 동적(파라미터화) 단위 테스트를 생성하는 방법은 무엇입니까? (0) | 2022.12.25 |
|---|---|
| MariaDB 10.2가 Percona XtraDB 대신 InnoDB를 다시 사용하는 이유는 무엇입니까? (0) | 2022.12.25 |
| 메모리 효율이 뛰어난 SqlAlchemy Iterator/Generator 내장 (0) | 2022.12.05 |
| ReactJ는 HTML 문자열을 JSX로 변환합니다. (0) | 2022.12.05 |
| Java 8 컨스트럭터 레퍼런스의 경이로운 퍼포먼스와 큰 히프 풋프린트 (0) | 2022.12.05 |