Generieren Sie Zeichenfolgen mit fester Länge, die mit Leerzeichen gefüllt sind

Ich muss eine Zeichenfolge mit fester Länge erstellen, um eine auf Zeichenpositionen basierende Datei zu generieren. Die fehlenden Zeichen müssen mit Leerzeichen gefüllt werden.

Das Feld CITY hat beispielsweise eine feste Länge von 15 Zeichen. Für die Eingänge "Chicago" und "Rio de Janeiro" sind die Ausgänge

"Chicago"
" Rio de Janeiro"

Seit Java 1.5 können wir die Methode java.lang.String.format (String, Object ...) verwenden und das printf-ähnliche Format verwenden.

Die Formatzeichenfolge erledigt "%1$15s"den Job. Wobei 1$der Argumentindex sangibt, dass das Argument ein String ist und 15die minimale Breite des Strings darstellt. Alles zusammen : "%1$15s".

Für eine allgemeine Methode haben wir:

public static String fixedLengthString(String string, int length) {
    return String.format("%1$"+length+ "s", string);
}

Vielleicht kann jemand eine andere Formatzeichenfolge vorschlagen, um die leeren Stellen mit einem bestimmten Zeichen zu füllen?

Verwenden Sie String.formatdie Polsterung mit Leerzeichen und ersetzen Sie sie durch das gewünschte Zeichen.

String toPad = "Apple";
String padded = String.format("%8s", toPad).replace(' ', '0');
System.out.println(padded);

Druckt 000Apple.

Aktualisieren Sie eine leistungsfähigere Version (da sie nicht darauf angewiesen ist String.format), die kein Problem mit Leerzeichen hat (danke an Rafael Borja für den Hinweis).

int width = 10;
char fill = '0';

String toPad = "New York";
String padded = new String(new char[width - toPad.length()]).replace('\0', fill) + toPad;
System.out.println(padded);

Druckt 00New York.

Es muss jedoch eine Prüfung hinzugefügt werden, um den Versuch zu verhindern, ein char-Array mit negativer Länge zu erstellen.

Dieser Code enthält genau die angegebene Anzahl von Zeichen. mit Leerzeichen gefüllt oder auf der rechten Seite abgeschnitten:

private String leftpad(String text, int length) {
    return String.format("%" + length + "." + length + "s", text);
}

private String rightpad(String text, int length) {
    return String.format("%-" + length + "." + length + "s", text);
}

Sie können auch eine einfache Methode wie unten schreiben

public static String padString(String str, int leng) {
        for (int i = str.length(); i <= leng; i++)
            str += " ";
        return str;
    }

Für das richtige Pad brauchst du String.format("%0$-15s", str)

Das heißt, das -Zeichen wird "rechts" und kein -Zeichen wird "links"

siehe mein Beispiel hier

http://pastebin.com/w6Z5QhnJ

Die Eingabe muss eine Zeichenfolge und eine Zahl sein

Beispieleingabe: Google 1

import org.apache.commons.lang3.StringUtils;

String stringToPad = "10";
int maxPadLength = 10;
String paddingCharacter = " ";

StringUtils.leftPad(stringToPad, maxPadLength, paddingCharacter)

Viel besser als Guava imo. Ich habe noch nie ein einziges Java-Unternehmensprojekt gesehen, das Guava verwendet, aber Apache String Utils ist unglaublich häufig.

Die Guava-Bibliothek verfügt über Strings.padStart , das genau das tut, was Sie wollen, zusammen mit vielen anderen nützlichen Dienstprogrammen.

Hier ist ein ordentlicher Trick:

// E.g pad("sss","00000000"); should deliver "00000sss".
public static String pad(String string, String pad) {
  /*
   * Add the pad to the left of string then take as many characters from the right 
   * that is the same length as the pad.
   * This would normally mean starting my substring at 
   * pad.length() + string.length() - pad.length() but obviously the pad.length()'s 
   * cancel.
   *
   * 00000000sss
   *    ^ ----- Cut before this character - pos = 8 + 3 - 8 = 3
   */
  return (pad + string).substring(string.length());
}

public static void main(String[] args) throws InterruptedException {
  try {
    System.out.println("Pad 'Hello' with '          ' produces: '"+pad("Hello","          ")+"'");
    // Prints: Pad 'Hello' with '          ' produces: '     Hello'
  } catch (Exception e) {
    e.printStackTrace();
  }
}

Hier ist der Code mit Testfällen;):

@Test
public void testNullStringShouldReturnStringWithSpaces() throws Exception {
    String fixedString = writeAtFixedLength(null, 5);
    assertEquals(fixedString, "     ");
}

@Test
public void testEmptyStringReturnStringWithSpaces() throws Exception {
    String fixedString = writeAtFixedLength("", 5);
    assertEquals(fixedString, "     ");
}

@Test
public void testShortString_ReturnSameStringPlusSpaces() throws Exception {
    String fixedString = writeAtFixedLength("aa", 5);
    assertEquals(fixedString, "aa   ");
}

@Test
public void testLongStringShouldBeCut() throws Exception {
    String fixedString = writeAtFixedLength("aaaaaaaaaa", 5);
    assertEquals(fixedString, "aaaaa");
}


private String writeAtFixedLength(String pString, int lenght) {
    if (pString != null && !pString.isEmpty()){
        return getStringAtFixedLength(pString, lenght);
    }else{
        return completeWithWhiteSpaces("", lenght);
    }
}

private String getStringAtFixedLength(String pString, int lenght) {
    if(lenght < pString.length()){
        return pString.substring(0, lenght);
    }else{
        return completeWithWhiteSpaces(pString, lenght - pString.length());
    }
}

private String completeWithWhiteSpaces(String pString, int lenght) {
    for (int i=0; i<lenght; i++)
        pString += " ";
    return pString;
}

Ich mag TDD;)

String.format("%15s",s) // pads right
String.format("%-15s",s) // pads left

Tolle Zusammenfassung hier

Dieser Code funktioniert hervorragend.

  String ItemNameSpacing = new String(new char[10 - masterPojos.get(i).getName().length()]).replace('\0', ' ');
  printData +=  masterPojos.get(i).getName()+ "" + ItemNameSpacing + ":   " + masterPojos.get(i).getItemQty() +" "+ masterPojos.get(i).getItemMeasure() + "\n";

Viel Spaß beim Codieren !!

public static String padString(String word, int length) {
    String newWord = word;
    for(int count = word.length(); count < length; count++) {
        newWord = " " + newWord;
    }
    return newWord;
}

Diese einfache Funktion funktioniert bei mir:

public static String leftPad(String string, int length, String pad) {
      return pad.repeat(length - string.length()) + string;
    }

Aufruf:

String s = leftPad(myString, 10, "0");