Wie kann ich einen String in Java auffüllen?

431

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

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

pvgoddijn
quelle
In Bezug auf die Apache-Funktion im Vergleich zum String-Formatierer besteht kaum ein Zweifel daran, dass die Apache-Funktion klarer und leichter zu lesen ist. Das Umschließen des Formatierers in Funktionsnamen ist nicht ideal.
Terra Caines

Antworten:

188

Apache StringUtilshat mehrere Methoden: leftPad, rightPad, centerund repeat.

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

GaryF
quelle
91
java.util.Formatter (und String.format ()) tun dies. Ziehen Sie das JDK immer einer externen Bibliothek vor, wenn die JDK-Version den Job erledigt (was sie auch tut).
Cletus
6
Aus mehreren Gründen würde ich Guava jetzt Apache Commons vorziehen. Diese Antwort zeigt, wie es in Guave geht .
Jonik
1
@ Jonik Möchten Sie einige Ihrer Gründe auflisten? Die APIs sehen ziemlich gleich aus.
Glen3B
3
@ glen3b: Für ein einzelnes Dienstprogramm, wie diese Hilfsprogramme zum Auffüllen von Zeichenfolgen, spielt es keine Rolle, welche Bibliothek verwendet werden soll. Trotzdem ist Guava insgesamt eine modernere, sauberere und besser dokumentierte Bibliothek als ihre Kollegen in verschiedenen Apache Commons-Projekten (Commons Lang, Commons Collections, Commons IO usw.). Es wurde auch von wirklich klugen Leuten (Kevin Bourrillion et al.) Gebaut, von denen viele bei SO aktiv sind . Ich selbst habe vor Jahren die verschiedenen Apache Commons-Bibliotheken durch Guava ersetzt und habe es nicht bereut.
Jonik
3
@ glen3b: Einige gute weiterführende Literatur zu dieser Frage .
Jonik
634

Seit Java 1.5 String.format()kann verwendet werden, um eine bestimmte Zeichenfolge 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*
RealHowTo
quelle
39
Was ist, wenn Sie mit anderen Zeichen (nicht Leerzeichen) arbeiten müssen? Ist es mit String.format noch möglich? Ich kann es nicht zum
Guido
6
AFAIK String.format () kann das nicht, aber es ist nicht allzu schwierig, es zu codieren, siehe rgagnon.com/javadetails/java-0448.html (2. Beispiel)
RealHowTo
61
@ Nullw0rm, wenn Sie sich auf rgagnon.com beziehen, beachten Sie, dass RealHowTo auch der Autor von rgagnon.com ist, also würde er sich selbst gutschreiben ...
Colin Pickard
3
Zumindest auf meiner JVM funktioniert das "#" nicht, das "-" ist in Ordnung. (Löschen Sie einfach das #). Dies kann mit der Formatierungsdokumentation übereinstimmen, ich weiß nicht; Es heißt "'#' '\ u0023'. Für die Ausgabe muss ein alternatives Formular verwendet werden. Die Definition des Formulars wird durch die Konvertierung angegeben."
Gatoatigrado
6
Danke für die tolle Antwort. Ich habe jedoch Zweifel, wofür ist das 1$? @leo hat eine sehr ähnliche Antwort gegeben, die nicht verwendet wird 1$und anscheinend den gleichen Effekt hat. Macht es einen Unterschied?
Fabrício Matté
257

Auffüllen 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

Zeigen Sie '*' für Zeichen des Passworts an:

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

Die Ausgabe hat dieselbe Länge wie die Kennwortzeichenfolge:

  secret123
  *********
Löwe
quelle
50
Nur solange wir uns alle daran erinnern, keine Zeichenfolge mit Leerzeichen
einzugeben
4
Ich bin bei @ Aboveyou00 - dies ist eine schreckliche Lösung für Zeichenfolgen mit Leerzeichen, einschließlich des Beispiels von Leo. Eine Lösung zum Auffüllen einer Zeichenfolge links oder rechts sollte die Eingabezeichenfolge, wie sie in der Ausgabe angezeigt wird, nicht ändern, es sei denn, die ursprüngliche Auffüllung der Eingabezeichenfolge bewirkt, dass sie die angegebene Auffülllänge überschreitet.
Brian Warshaw
3
Bestätigen Sie das Platzproblem. .replace(' ', '*')sollte eher die Wirkung der Polsterung zeigen. Der Ausdruck zum Ausblenden von Passwörtern hat dieses Problem ohnehin nicht ... Eine bessere Antwort zum Anpassen der linken und rechten Füllzeichenfolge mithilfe der nativen Java-Funktion finden Sie in meiner anderen Antwort.
Leo
Wenn die Zeichenfolge nur einzelne Leerzeichen enthält und Sie mit unterschiedlichen Zeichen String.format("%30s", "pad left").replaceAll("(?<=( |^)) ", "*")String.format("%-30s", "pad right").replaceAll(" (?=( |$))", "*")
Jaroslaw Pawlak
88

In Guave ist das einfach:

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

Etwas Einfaches:

Der Wert sollte eine Zeichenfolge sein. Konvertieren Sie es in einen String, wenn dies nicht der Fall ist. Wie "" + 123oderInteger.toString(123)

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

Die Teilzeichenfolge beginnt vom Zeichenlängen-Zeichenindex bis zur Endlänge der gepolsterten:

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"
Shimon Doodkin
quelle
24

Schau es dir an org.apache.commons.lang.StringUtils#rightPad(String str, int size, char padChar).

Der Algorithmus ist jedoch sehr einfach (Pad bis zur Größe der Zeichen):

public String pad(String str, int size, char padChar)
{
  StringBuffer padded = new StringBuffer(str);
  while (padded.length() < size)
  {
    padded.append(padChar);
  }
  return padded.toString();
}
Arne Burmeister
quelle
11
Beachten Sie, dass es sich ab Java 1.5 lohnt, StringBuilder anstelle von StringBuffer zu verwenden.
Jon Skeet
21

Sehen Sie neben Apache Commons auch, String.formatwelche in der Lage sein sollten, sich um einfaches Auffüllen zu kümmern (z. B. mit Leerzeichen).

Elende Variable
quelle
17
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...
Eduardo
quelle
4
Achten Sie darauf: Sie haben Funktionsnamen invertiert; Wenn Sie es ausführen, werden Sie sehen.
bläulich
Plus, wenn die ursprüngliche str Leerzeichen enthält, dann funktioniert dies nicht
Steven Shaw
@StevenShaw Wenn ich mich nicht irre, zielt der Ersatz nicht auf das Original ab str, daher ist dies korrekt.
Mafu
3
Konventionell sollten Sie für Funktionsnamen keinen Großbuchstaben verwenden.
Principal-Ideal-Domain
Gibt es eine fehlende Bedingung für die Rückgabe der Zeichenfolge wie sie (length - str.length())ist 0? Der Formatierer gibt ein FormatFlagsConversionMismatchExceptionWann aus, %0sdas die Formatzeichenfolge ist.
Devin Walters
7

Ich brauchte eine Weile, um das herauszufinden. Der eigentliche Schlüssel ist das Lesen dieser Formatter-Dokumentation.

// 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);
Nthalk
quelle
Warum das Ende so kompliziert machen? Sie hätten einfach String hex = String.format ("% 032x", Digest) ausführen können; und hatte genau die gleichen Ergebnisse, nur ohne unnötiges Ersetzen () und mit dem $ auf bestimmte Variablen zugreifen zu müssen (es gibt schließlich nur eine.)
ArtOfWarfare
@ArtOfWarfare fair point. Jemand fragte ursprünglich nach dem Auffüllen von Hex-Werten in einer anderen Frage. Ich sah, dass ich einen Link zur Formatierungsdokumentation hatte. Der Vollständigkeit halber ist es kompliziert.
Nthalk
6

Ich weiß, dass dieser Thread etwas alt ist und die ursprüngliche Frage war für eine einfache Lösung, aber wenn es wirklich schnell sein 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 einfaches Erstellen der Formatzeichenfolge werden zwei neue Zeichenfolgen erstellt.

Die Lösung von Apache kann verbessert werden, indem der sb mit der Zielgröße initialisiert wird, die unten ersetzt wird

StringBuffer padded = new StringBuffer(str); 

mit

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

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

ck.
quelle
Wenn StringBuffernicht mehrere Threads gleichzeitig auf das StringBuilderzugreifen können (was in diesem Fall zutrifft), sollten Sie ein (in JDK1.5 +) verwenden, um den Aufwand für die Synchronisierung zu vermeiden.
Glen3B
5

Hier ist eine andere Möglichkeit, nach rechts zu tippen:

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

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

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

Ausgabe:

*****apple
apple*****
Eko Setiawan
quelle
1
Beste Antwort für Java 11!
Nagy Attila
4

Sie können den Overhead pro Anruf reduzieren, indem Sie die Auffülldaten beibehalten, anstatt sie jedes Mal neu zu 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 zu einem Parameter für die pad(...)Methode machen. Nehmen Sie in diesem Fall die Anpassung der ausgeblendeten Auffüllung in dieser Methode anstelle im Konstruktor vor.

(Hinweis: Für zusätzliche Gutschrift machen Sie es threadsicher! ;-)

joel.neely
quelle
1
Das ist threadsicher, außer bei unsicheren Veröffentlichungen (machen Sie Ihre Felder selbstverständlich endgültig). Ich denke, die Leistung könnte verbessert werden, indem ein Teilstring vor dem + erstellt wird, der (seltsamerweise) durch concat ersetzt werden sollte.
Tom Hawtin - Tackline
3

Fand dies auf Dzone

Pad mit Nullen:

String.format("|%020d|", 93); // prints: |00000000000000000093|
ABl
quelle
Dies sollte die Antwort sein, einfach und präzise, ​​ohne dass externe Bibliotheken installiert werden müssen.
Wong Jia Hau
2

Sie können die integrierten Methoden StringBuilder append () und insert () zum Auffüllen variabler Zeichenfolgenlängen verwenden:

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

Das funktioniert:

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

Es füllt Ihren String XXX mit bis zu 9 Zeichen mit einem Leerzeichen. Danach werden alle Leerzeichen durch eine 0 ersetzt. Sie können das Leerzeichen und die 0 nach Belieben ändern ...

Sebastian S.
quelle
Sie sollten die staticMethode aufrufen , String.format(…)anstatt eine leere Zeichenfolge zu missbrauchen. Das Speichern von vier Zeichen im Quellcode ist den Verlust der Lesbarkeit sicherlich nicht wert.
Holger
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 "";
}
Marlon Tarax
quelle
2

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

Das gleiche wie bei der ausgewählten Antwort würde ich die StringUtilsvon Apache Commons bevorzugen, aber auf folgende Weise:

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

Erklären:

  • myString: Die von mir eingegebene Zeichenfolge kann null sein
  • StringUtils.leftPad(myString, 1): Wenn string null ist, würde diese Anweisung auch null zurückgeben
  • Verwenden Sie dann defaultString, um eine leere Zeichenfolge anzugeben, um zu verhindern, dass null verkettet wird
Osify
quelle
2

Die Antworten von @ck und @Marlon Tarak sind die einzigen, die a verwenden. Dieschar[] ist der beste Ansatz für Anwendungen, bei denen mehrere Auffüllmethoden pro Sekunde aufgerufen werden . Sie nutzen jedoch keine Optimierungen der Array-Manipulation und werden für meinen Geschmack ein wenig überschrieben. Dies kann ohne Schleifen erfolgen .

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 
ndm13
quelle
1
Sie können getCharsden StringInhalt direkt in das outArray kopieren lassen , anstatt ihn aufzurufen source.toCharArray(), gefolgt von System.arraycopy. Ich würde sogar in Betracht ziehen, die Implementierung zu vereinfachen char[] out = new char[length]; Arrays.fill(out, 0, length, fill); source.getChars(0, source.length(), out, right? 0: length - source.length()); return new String(out);. Dies scheint fillzwar mehr Arbeit zu leisten, ermöglicht es der JVM jedoch, die standardmäßige Nullfüllung zu beseitigen.
Holger
1

java.util.Formatterwird links und rechts Polsterung tun. 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 zum 'Community-Wiki' gemacht, da ich ihn nicht brauche.]

Tom Hawtin - Tackline
quelle
4
Ich stimme dir nicht zu. In jedem größeren Java-Projekt werden Sie normalerweise so viele Zeichenfolgen manipulieren, dass sich die verbesserte Lesbarkeit und Vermeidung von Fehlern mit Apache Commons Lang lohnt. Sie alle kennen Code wie someString.subString (someString.indexOf (startCharacter), someString.lastIndexOf (endCharacter)), der mit StringUtils leicht vermieden werden kann.
Bananeweizen
1

Alle Zeichenfolgenoperationen müssen normalerweise sehr effizient sein - insbesondere, wenn Sie mit großen Datenmengen arbeiten. Ich wollte etwas, das schnell und flexibel ist, ähnlich dem, was Sie im Befehl plsql pad erhalten. Außerdem möchte ich keine große Bibliothek für nur eine kleine Sache einfügen. Mit diesen Überlegungen war keine dieser Lösungen zufriedenstellend. Dies sind die Lösungen, die ich gefunden habe und die die besten Benchmarking-Ergebnisse erzielt haben. Wenn jemand sie 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 dem neuen String ((char []) - Ergebnis) in String konvertiert werden kann. Der Grund dafür ist, dass Sie, wenn Sie mehrere Operationen anwenden, diese alle auf char [] ausführen und nicht weiter zwischen Formaten konvertieren können - hinter den Kulissen wird String als char [] gespeichert. Wenn diese Operationen in der String-Klasse selbst enthalten wären, wäre sie doppelt so effizient gewesen - Geschwindigkeit und Speicher.
EarlB
quelle
Dies
scheint in der
1

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

Samet ÖZTOPRAK
quelle
1

Viele Leute haben einige sehr interessante Techniken, aber ich mag es einfach zu halten, also gehe ich so vor:

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();
}
Aelphaeis
quelle
2
Dies ist sehr ineffizient, Sie sollten einen StringBuilder verwenden
wkarl
Da Sie die Länge bereits kennen, sollten Sie den StringBuilder anweisen, so viel Speicherplatz zuzuweisen, wenn Sie ihn instanziieren.
Ariel
@Ariel interessant, dass Sie das erwähnen, weil ich heute gerade mit jemand anderem darüber gesprochen habe lol.
Aelphaeis
0

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

Java-Oneliner, keine schicke Bibliothek.

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

Pad Links, 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 Links, Begrenzung auf Padlänge

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

Pad Rechts auf Limitlänge beschränken

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

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

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

HINWEIS : Bei dieser Lösung wird das Auffüllen angehängt. Mit einer kleinen Änderung können Sie dem Pad-Wert ein Präfix voranstellen.

Saikat
quelle
0

Hier ist eine parallele Version für diejenigen von euch, die sehr lange Saiten haben :-)

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));
David Lilljegren
quelle
0

Auffüllbeispiele in Guave:

Auffüllbeispiele in Apache Commons:

Auffüllbeispiele in JDK:

APISonar
quelle
-1

Eine einfache Lösung wäre:

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

Wie ist das

Die Zeichenfolge ist "Hallo" und die erforderliche Auffüllung ist 15 mit der linken Auffüllung "0"

String ax="Hello";
while(ax.length() < 15) ax="0"+ax;
Satwant
quelle
10
Dieser generiert bis zu 15 neue Zeichenfolgen.
Claj
@laj Ja, aber das hier .
Ruffin