Genera stringhe di lunghezza fissa riempite con spazi bianchi

Ho bisogno di produrre una stringa di lunghezza fissa per generare un file basato sulla posizione dei caratteri. I caratteri mancanti devono essere riempiti con uno spazio.

Ad esempio, il campo CITY ha una lunghezza fissa di 15 caratteri. Per gli ingressi "Chicago" e "Rio de Janeiro" le uscite sono

"Chicago"
"Rio de Janeiro"

A partire da Java 1.5 possiamo usare il metodo java.lang.String.format (String, Object ...) e usare printf like format.

La stringa di formato "%1$15s"fa il lavoro. Dove 1$indica l'argomento index, sindica che l'argomento è una stringa e 15rappresenta la larghezza minima della stringa. Mettere tutto insieme: "%1$15s".

Per un metodo generale abbiamo:

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

Forse qualcuno può suggerire un'altra stringa di formato per riempire gli spazi vuoti con un carattere specifico?

Utilizza String.formatil riempimento di spazi con gli spazi e sostituiscili con il carattere desiderato.

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

Stampe 000Apple.

Aggiorna la versione più performante (dato che non si basa su String.format), che non ha problemi con gli spazi (grazie a Rafael Borja per il suggerimento).

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

Stampe 00New York.

Ma è necessario aggiungere un segno di spunta per evitare il tentativo di creare un array di caratteri con lunghezza negativa.

Questo codice avrà esattamente la quantità di caratteri specificata; riempito con spazi o troncato sul lato destro:

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

Puoi anche scrivere un metodo semplice come di seguito

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

Per il giusto pad hai bisogno String.format("%0$-15s", str)

cioè il -segno sarà "destro" e nessun -segno sarà "sinistro"

guarda il mio esempio qui

http://pastebin.com/w6Z5QhnJ

l'input deve essere una stringa e un numero

input di esempio: Google 1

import org.apache.commons.lang3.StringUtils;

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

StringUtils.leftPad(stringToPad, maxPadLength, paddingCharacter)

Molto meglio di Guava imo. Non ho mai visto un singolo progetto Java aziendale che utilizza Guava, ma Apache String Utils è incredibilmente comune.

La libreria Guava ha Strings.padStart che fa esattamente quello che vuoi, insieme a molte altre utili utilità.

Ecco un bel trucco:

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

Ecco il codice con i casi di test;):

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

Mi piace TDD;)

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

Ottimo riassunto qui

Questo codice funziona alla grande.

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

Codifica felice !!

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

Questa semplice funzione funziona per me:

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

Invocazione:

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