¿Cómo puedo Rellena una cadena en Java?

Question

¿Hay alguna forma fácil de Cuerdas almohadilla en Java?

Parece que algo que debería ser de alguna API StringUtil similar, pero no puedo encontrar cualquier cosa que hace esto.

Answer 1

StringUtils tiene varios métodos: leftPad , rightPad , center y repeat .

Sin embargo, tenga en cuenta que - como otros han mencionado y demostrado en esta respuesta - String.format() y las clases Formatter en el JDK son mejores opciones. Utilizarlos sobre el código de bienes comunes.

Answer 2

Desde Java 1,5, String.format() se puede utilizar para la izquierda / derecha almohadilla de una cadena dada.

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) + "*");
}

Y la salida es:

Howto               *
               Howto*

Answer 3

Relleno a 10 caracteres:

String.format("%10s", "foo").replace(' ', '*');
String.format("%-10s", "bar").replace(' ', '*');
String.format("%10s", "longer than 10 chars").replace(' ', '*');

salida:

  *******foo
  bar*******
  longer*than*10*chars

Pantalla '*' para los caracteres de la contraseña:

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

salida tiene la misma longitud que la cadena de contraseña:

  secret123
  *********

Answer 4

guayaba , esto es fácil:

Strings.padStart("string", 10, ' ');
Strings.padEnd("string", 10, ' ');

Answer 5

Algo simple:

El valor debe ser una cadena. convertirlo en cadena, si no lo es. Al igual que "" + 123 o Integer.toString(123)

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

inicio Substring del índice de longitud valor Char hasta que la longitud final del acolchado:

String padded="00000000".substring(value.length()) + value;

// now padded is "00000123"

más precisa

pastilla derecha:

String padded = value + ("ABCDEFGH".substring(value.length())); 

// now padded is "123DEFGH"

almohadilla izquierda:

String padString = "ABCDEFGH";
String padded = (padString.substring(0, padString.length() - value.length())) + value;

// now padded is "ABCDE123"

Answer 6

Tener un vistazo a org.apache.commons.lang.StringUtils#rightPad(String str, int size, char padChar).

Sin embargo, el algoritmo es muy simple (almohadilla hasta caracteres de tamaño):

public String pad(String str, int size, char padChar)
{
  StringBuffer padded = new StringBuffer(str);
  while (padded.length() < size)
  {
    padded.append(padChar);
  }
  return padded.toString();
}

Answer 7

Además Apache Commons, también ver String.format que debe ser capaz de tener cuidado de sencilla de relleno (por ejemplo con espacios).

Answer 8

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...

Answer 9

Esto me tomó un poco de tiempo para averiguar. La verdadera clave es leer que la documentación formateador.

// 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 10

sé que este hilo es un poco viejo y la pregunta original era para una solución fácil, pero si se supone que debe ser un proceso más rápido, se debe utilizar un array de caracteres.

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

la solución formateador no es óptima. sólo la construcción de la cadena de formato crea 2 nuevas cadenas.

solución de Apache se puede mejorar mediante la inicialización del sb con el tamaño de destino por lo que reemplazar abajo

StringBuffer padded = new StringBuffer(str); 

con

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

impediría el buffer interno del sb de crecimiento.

Answer 11

Aquí es otra forma de cojín a la derecha:

// 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 12

Puede reducir la sobrecarga por llamada mediante la retención de los datos de relleno, en lugar de reconstruir cada vez:

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

}

Como alternativa, puede hacer que la longitud del resultado de un parámetro al método pad(...). En ese caso, realizar el ajuste del relleno oculto en ese método en lugar de en el constructor.

(Pista: Para el crédito adicional, que sea seguro para subprocesos; -)

Answer 13

Encontramos en Dzone

Pad con ceros:

String.format("|%020d|", 93); // prints: |00000000000000000093|

Answer 14

puede utilizar el construido en modo de adición StringBuilder () e insertar () métodos, para el relleno de longitudes de cadena variables:

AbstractStringBuilder append(CharSequence s, int start, int end) ;

Por ejemplo:

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

Answer 15

Esto funciona:

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

Se va a llenar su cadena XXX hasta 9 caracteres con un espacio en blanco. Después de que todos los espacios en blanco será reemplazado por un 0. Se puede cambiar el espacio en blanco y el 0 a lo que quieras ...

Answer 16

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

Answer 17

me permite dejo una respuesta para algunos casos que usted necesita para dar relleno a la izquierda / derecha (o prefijo / cadena sufijo o espacios) antes de concatenar a otra cadena y no quiero poner a prueba la longitud o cualquier si la condición.

Lo mismo que la respuesta seleccionada, yo preferiría que el StringUtils de Apache Commons pero utilizando de esta manera:

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

Explicar:

• myString: la cadena de entrada I, puede ser nulo
• StringUtils.leftPad(myString, 1): si la cadena es nulo, esta declaración volvería nula demasiado
• a continuación, utilizar defaultString para dar cadena vacía para evitar nula concatenar

Answer 18

@ck 's y respuestas @Marlon Tarak 's son los únicos que utilizan un char[], que para las aplicaciones que tienen varias llamadas a métodos de relleno por segundo es el mejor enfoque. Sin embargo, no se aprovechan las optimizaciones de manipulación de matriz y son un poco sobrescribe para mi gusto; esto se puede hacer con no hay bucles en absoluto .

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

método de prueba simple:

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

Salidas:

012345678901234567890123456789
cats                          
                          cats
                cats
cats$$$$$$$$$$$$$$$$$$$$$$$$$$
too long for your own good, buddy 

Answer 19

java.util.Formatter hará relleno a la izquierda y la derecha. No hay necesidad de dependencias impares de terceros (¿le gustaría añadir por algo tan trivial).

[He dejado de lado los detalles e hice este post 'wiki de la comunidad', ya que no es algo que tengo una necesidad de.]

Answer 20

Utilice esta función.

private String leftPadding(String word, int length, char ch) {
   return (length > word.length()) ? leftPadding(ch + word, length, ch) : word;
}

cómo utilizar?

leftPadding(month, 2, '0');

salida: 01 02 03 04 11 12 ..

Answer 21

Una gran cantidad de personas que tienen algunas técnicas muy interesantes, pero me gusta que sea sencillo así que voy con esto:

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

Answer 22

Desde Java 11, String.repeat (int) se puede utilizar para la izquierda / derecha almohadilla de una cadena dada.

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

Salida:

*****apple
apple*****

Answer 23

Una solución simple sin ninguna API será como sigue:

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

Answer 24

oneliners Java, ninguna biblioteca de fantasía.

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

Izquierda Pad, no se limite

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

Libreta de derecho, no se limite

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

Pad Izquierda, límite a la longitud de la almohadilla

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

Pad Derecha, límite a la longitud de la almohadilla

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

Answer 25

Todo cadena operación generalmente tiene que ser muy eficiente - sobre todo si se trabaja con grandes conjuntos de datos. Yo quería algo que es rápido y flexible, similar a lo que se obtiene al mando plsql almohadilla. Además, no quiero incluir una enorme lib por sólo una pequeña cosa. Con estas consideraciones ninguna de estas soluciones fueron satisfactorios. Esta es la solución que se me ocurrió, que tuvieron los mejores resultados de cotas de referencia, si alguien puede mejorar en él, por favor agregue su comentario.

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

• Nota se le llama con String.toCharArray () y el resultado se puede convertir en cadena con nueva cadena ((char []) resultado). La razón de esto es que, si la aplicación de múltiples operaciones que se pueden hacer todos ellos en char [] y no seguir la conversión entre formatos - detrás de las escenas, cadena se almacena como char []. Si estas operaciones fueron incluidas en la propia clase String, que habría sido el doble de eficiente -. Velocidad y la memoria sabia

Answer 26

¿Cómo sobre el uso de la recursividad? Solución dada a continuación es compatible con todas las versiones de JDK y no hay bibliotecas externas necesarias:)

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

Nota: . Esta solución va a añadir el relleno, con un pequeño arreglo puede prefijar el valor del atenuador

Answer 27

Una solución sencilla sería:

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

Answer 28

¿Cómo es esto

cadena es "Hola" y el relleno requerido es 15 con "0" de la almohadilla izquierda

String ax="Hello";
while(ax.length() < 15) ax="0"+ax;