it-swarm.com.de

Wie kann ich einen String in Java auffüllen?

Gibt es eine einfache Möglichkeit, Strings in Java aufzufüllen?

Scheint wie etwas, das in einer StringUtil-ähnlichen API enthalten sein sollte, aber ich kann nichts finden, das dies tut.

373
pvgoddijn

Apache StringUtils hat mehrere Methoden: leftPad , rightPad , center und repeat

Beachten Sie jedoch, dass - wie andere in dieser Antwort erwähnt und gezeigt haben - String.format() und die Formatter-Klassen im JDK bessere Optionen sind. Verwenden Sie sie über dem Commons-Code.

159
GaryF

Seit Java 1.5 kann String.format() verwendet werden, um eine Zeichenfolge nach links/rechts aufzufüllen.

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

Und die Ausgabe ist:

Howto               *
               Howto*
567
RealHowTo

Auffüllung auf 10 Zeichen:

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

ausgabe:

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

Anzeige '*' für Passwortzeichen:

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

die Ausgabe hat dieselbe Länge wie die Kennwortzeichenfolge:

  secret123
  *********
234
leo

In Guave ist das einfach:

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

Etwas einfaches:

Der Wert sollte eine Zeichenfolge sein. konvertieren Sie es in einen String, wenn nicht. Wie "" + 123 oder Integer.toString(123)

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

Unterzeichenfolge beginnt mit dem Wert length char index bis zum Ende der aufgefüllten Länge:

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

// now padded is "00000123"

Etwas genauer  

pad rechts:

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

// now padded is "123DEFGH"

pad links:

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

// now padded is "ABCDE123"
29
Shimon Doodkin

Schauen Sie sich org.Apache.commons.lang.StringUtils#rightPad(String str, int size, char padChar) an.

Der Algorithmus ist jedoch sehr einfach (Pad bis zu Zeichengrößen):

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

Siehe neben Apache Commons auch String.format, der für einfaches Auffüllen (z. B. mit Leerzeichen) sorgen kann.

21
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...
16
Eduardo

Ich brauchte eine Weile, bis ich herausgefunden hatte ... Der eigentliche Schlüssel ist, diese Formatter-Dokumentation zu lesen.

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

ich weiß, dass dieser Thread ein bisschen alt ist und die ursprüngliche Frage war eine einfache Lösung, aber wenn es wirklich schnell gehen soll, sollten Sie ein Char-Array verwenden.

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

die Formatierungslösung ist nicht optimal. Durch das Erstellen der Formatzeichenfolge werden 2 neue Zeichenfolgen erstellt.

Die Lösung von Apache kann durch die Initialisierung von sb mit der Zielgröße verbessert werden

StringBuffer padded = new StringBuffer(str); 

mit 

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

würde verhindern, dass der interne Puffer der sb wächst.

6
ck.

Hier ist eine weitere Möglichkeit, um nach rechts zu polstern:

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

Sie können den Aufwand pro Anruf reduzieren, indem Sie die Auffülldaten beibehalten und nicht jedes Mal neu erstellen:

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

}

Alternativ können Sie die Ergebnislänge als Parameter für die pad(...)-Methode festlegen. In diesem Fall nehmen Sie die Einstellung der verborgenen Polsterung in dieser Methode anstelle des Konstruktors vor.

(Hinweis: Für extra Gutschrift machen Sie es fadensicher! ;-)

4
joel.neely
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 "";
}
2
Marlon Tarax

Fand dies auf Dzone

Mit Nullen auffüllen:

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

sie können die eingebauten StringBuilder-Methoden append () und insert ().

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

Zum Beispiel:

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

Das funktioniert:

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

Es füllt Ihre Zeichenfolge XXX bis zu 9 Zeichen mit einem Leerzeichen. Danach werden alle Whitespaces durch eine 0 ersetzt. Sie können den Whitespace und die 0 in das ändern, was Sie möchten ...

2
Sebastian S.

Lassen Sie mich eine Antwort für einige Fälle hinterlassen, die Sie links/rechts (oder Präfix-/Suffix-Zeichenfolge oder Leerzeichen) angeben müssen, bevor Sie zu einer anderen Zeichenfolge verketten, und Sie möchten nicht die Länge oder die Bedingung if überprüfen.

Dasselbe gilt für die ausgewählte Antwort. Ich würde die StringUtils von Apache Commons vorziehen, aber auf diese Weise:

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

Erklären:

  • myString: Die von mir eingegebene Zeichenfolge kann Null sein
  • StringUtils.leftPad(myString, 1): Wenn die Zeichenfolge null ist, würde diese Anweisung ebenfalls null zurückgeben
  • verwenden Sie dann defaultString, um eine leere Zeichenfolge anzugeben, um die Verkettung von Null zu verhindern
2
Osify

@ck 's und @Marlon Tarak ' s Antworten sind die einzigen, die einen char[] verwenden, der für Anwendungen mit mehreren Aufrufen von Padding-Methoden pro Sekunde der beste Ansatz ist. Sie nutzen jedoch keine Array-Manipulationsoptimierungen und werden für meinen Geschmack etwas überschrieben. Dies ist mit no loops möglich.

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

Einfache Testmethode:

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

Ausgänge:

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

Viele Leute haben einige sehr interessante Techniken, aber ich mag es, es einfach zu halten. 

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

Java.util.Formatter wird links und rechts aufgefüllt. Keine Notwendigkeit für ungerade Abhängigkeiten von Drittanbietern (möchten Sie sie für etwas so Triviales hinzufügen).

[Ich habe die Details ausgelassen und diesen Beitrag als "Community-Wiki" erstellt, da ich dies nicht brauche.]

Verwenden Sie diese Funktion.

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

wie benutzt man? 

leftPadding(month, 2, '0');

ausgabe: 01 02 03 04 .. 11 12

1
Samet öztoprak

Alle StringOperationen müssen in der Regel sehr effizient sein - insbesondere wenn Sie mit großen Datenmengen arbeiten. Ich wollte etwas, das schnell und flexibel ist, ähnlich dem, was Sie mit dem Befehl plsql pad erhalten. Außerdem möchte ich keine große Bibliothek für eine kleine Sache hinzufügen. Mit diesen Überlegungen war keine dieser Lösungen zufriedenstellend. Dies ist die Lösung, die ich mir ausgedacht habe und die besten Benchmarking-Ergebnisse erzielt hat. Wenn jemand etwas verbessern kann, fügen Sie bitte Ihren Kommentar hinzu.

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;
    }
}
  • beachten Sie, dass es mit String.toCharArray () aufgerufen wird und das Ergebnis mit neuem String ((char []) -Ergebnis) in String konvertiert werden kann. Der Grund dafür ist, wenn Sie mehrere Vorgänge ausführen, können Sie sie alle mit char [] ausführen und nicht zwischen Formaten konvertieren. Hinter den Kulissen wird String als char [] gespeichert. Wenn diese Vorgänge in der String-Klasse selbst enthalten wären, wäre dies doppelt so effizient gewesen - Geschwindigkeit und Speicherplatz.
0
EarlB

Seit Java 11 kann String.repeat (int) verwendet werden, um einen bestimmten String nach links/rechts aufzufüllen.

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

Ausgabe:

*****Apple
apple*****
0
Eko Setiawan

Java-Oneliner, keine schicke Bibliothek. 

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

Pad Left, nicht einschränken

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

Pad richtig, nicht einschränken

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

Pad Left, beschränken Sie sich auf die Padlänge

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

Pad Right, beschränken Sie sich auf die Padlänge

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

Eine einfache Lösung ohne API lautet wie folgt:

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

Wie wäre es mit Rekursion? Die unten angegebene Lösung ist mit allen JDK-Versionen kompatibel und benötigt keine externen Bibliotheken:)

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

NOTE: Bei dieser Lösung wird die Polsterung angehängt. Mit einem kleinen Tweak können Sie den Pad-Wert voranstellen.

0
Saikat Sengupta