Genere cadenas de longitud fija llenas de espacios en blanco

Necesito producir una cadena de longitud fija para generar un archivo basado en la posición de los caracteres. Los caracteres que faltan deben llenarse con espacio.

Como ejemplo, el campo CIUDAD tiene una longitud fija de 15 caracteres. Para las entradas "Chicago" y "Rio de Janeiro" las salidas son

"Chicago"
" Rio de Janeiro"

Desde Java 1.5 podemos usar el método java.lang.String.format (String, Object ...) y usar el formato printf.

La cadena de formato "%1$15s"hace el trabajo. Donde 1$indica el índice del argumento, sindica que el argumento es una Cadena y 15representa el ancho mínimo de la Cadena. Poniendo todo junto: "%1$15s".

Para un método general tenemos:

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

¿Quizás alguien pueda sugerir otra cadena de formato para llenar los espacios vacíos con un carácter específico?

Utilice String.formatel relleno con espacios y reemplácelos con el carácter deseado.

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

Impresiones 000Apple.

Actualice una versión más eficiente (ya que no depende de ella String.format), que no tiene problemas con los espacios (gracias a Rafael Borja por la pista).

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

Impresiones 00New York.

Pero se debe agregar una verificación para evitar el intento de crear una matriz de caracteres con longitud negativa.

Este código tendrá exactamente la cantidad de caracteres indicada; lleno de espacios o truncado en el lado derecho:

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

También puede escribir un método simple como el siguiente

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

Para la almohadilla derecha necesitas String.format("%0$-15s", str)

es decir, el -letrero tendrá el pad "derecho" y ningún -letrero será el pad "izquierdo"

mira mi ejemplo aquí

http://pastebin.com/w6Z5QhnJ

la entrada debe ser una cadena y un número

entrada de ejemplo: Google 1

import org.apache.commons.lang3.StringUtils;

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

StringUtils.leftPad(stringToPad, maxPadLength, paddingCharacter)

Mucho mejor que guayaba imo. Nunca he visto un solo proyecto empresarial de Java que use Guava, pero Apache String Utils es increíblemente común.

La biblioteca de Guava tiene Strings.padStart que hace exactamente lo que quiere, junto con muchas otras utilidades útiles.

Aquí hay un buen truco:

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

Aquí está el código con casos de prueba;):

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

Me gusta TDD;)

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

Gran resumen aquí

Este código funciona muy bien.

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

Codificación feliz !!

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

Esta sencilla función funciona para mí:

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

Invocación:

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