Wie kann ich einen String in Java auffüllen?

Question

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

Scheint wie etwas, das in einige StringUtil-ähnliche API sein sollte, aber ich kann nichts finden, die dies tut.

Answer 1

Ich weiß, dieser Thread ist irgendwie alt 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. Allein durch die Erstellung der Formatierungszeichenfolge werden 2 neue Zeichenfolgen erzeugt.

Die Lösung von apache kann verbessert werden, indem die sb mit der Zielgröße initialisiert wird, so dass Folgendes ersetzt wird

StringBuffer padded = new StringBuffer(str); 

con

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

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

Answer 2

Ich habe eine Weile gebraucht, um das herauszufinden. Der eigentliche Schlüssel ist, die Formatierungsdokumentation 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);

Answer 3

Hier ist eine weitere Möglichkeit, 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-------";

Answer 4

Sie können den Overhead pro Aufruf reduzieren, indem Sie die Auffüllungsdaten 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 als Parameter für die Funktion pad(...) Methode. In diesem Fall müssen Sie die versteckten Polsterungen in dieser Methode und nicht im Konstruktor anpassen.

(Tipp: Machen Sie es thread-sicher, um zusätzliche Punkte zu erhalten ;-)

Answer 5

Alle string Operation muss in der Regel sehr effizient - vor allem, wenn man mit großen Datenmengen arbeitet. Ich wollte etwas, das schnell und flexibel ist, ähnlich dem, was man mit dem Befehl plsql pad erhält. Außerdem wollte ich keine riesige Bibliothek für nur eine kleine Sache einbauen. Mit diesen Überlegungen war keine dieser Lösungen zufriedenstellend. Dies ist die Lösung, die ich mir ausgedacht habe und die die besten Benchmarking-Ergebnisse hatte. Wenn jemand sie verbessern kann, bitte einen Kommentar hinzufügen.

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 new String((char[])result) in String umgewandelt werden kann. Der Grund dafür ist, dass Sie bei der Anwendung mehrerer Operationen diese alle auf char[] anwenden können und nicht ständig zwischen den Formaten konvertieren müssen - hinter den Kulissen wird String als char[] gespeichert. Wären diese Operationen in der String-Klasse selbst enthalten, wäre sie doppelt so effizient - sowohl von der Geschwindigkeit als auch vom Speicher her.