tomar - ¿Cómo puedo rellenar una cadena en Java?

retornar una cadena en java

Question

¿Hay alguna forma fácil de rellenar cadenas en Java?

Parece algo que debería estar en alguna API similar a StringUtil, pero no puedo encontrar nada que haga esto.

Answer 1

Además de Apache Commons, también vea String.format que debería poder ocuparse de rellenos simples (por ejemplo, con espacios).

Answer 2

Aquí hay otra forma de rellenar 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 3

Cómo es esto

La cadena es "hola" y el relleno requerido es 15 con la tecla izquierda "0"

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

Answer 4

Desde Java 1.5, String.format() se puede usar para rellenar el lado izquierdo / derecho de una cadena dada.

public static String padRight(String s, int n) {
return String.format("%1$-" + n + "s", s);
}
public static String padLeft(String s, int n) {
return String.format("%1$" + 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 5

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

Pero el algoritmo es muy simple (rellena 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 6

En Guava , esto es fácil:

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

Answer 7

Encontré esto en Dzone

Pad con ceros:

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

Answer 8

Esto funciona:

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

Llenará tu Cadena XXX hasta 9 caracteres con un espacio en blanco. Después de eso, todos los espacios en blanco serán reemplazados por un 0. Puedes cambiar el espacio en blanco y el 0 a lo que quieras ...

Answer 9

Esto me tomó un poco de tiempo para averiguar. La verdadera clave es leer esa documentación del 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

Mucha gente tiene algunas técnicas muy interesantes, pero me gusta que sea sencillo, así que continúo 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 11

Oneliners de Java, no hay biblioteca de lujo.

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

Pad Left, no limite

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

Pad Derecho, no limites

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

Almohadilla izquierda, límite a la longitud de la almohadilla

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

Almohadilla derecha, límite a la longitud de la almohadilla

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

Answer 12

Permítanme dejarles una respuesta para algunos casos en los que necesita dar relleno izquierdo / derecho (o prefijo / sufijo de cadena o espacios) antes de concatenar con otra cadena y no desea probar la longitud o cualquier condición.

De la misma forma que la respuesta seleccionada, preferiría los StringUtils de Apache Commons pero utilizando esta forma:

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

Explique:

• myString : la cadena que ingreso, puede ser nula
• StringUtils.leftPad(myString, 1) : si la cadena es nula, esta instrucción también devolverá nula
• luego use defaultString para dar una cadena vacía para evitar concatenar nulo

Answer 13

Por lo general, todas las operaciones de cadena deben ser muy eficientes , especialmente si está trabajando con grandes conjuntos de datos. Quería algo que fuera rápido y flexible, similar a lo que obtendría con el comando plsql pad. Además, no quiero incluir una gran biblioteca por solo una pequeña cosa. Con estas consideraciones ninguna de estas soluciones fue satisfactoria. Estas son las soluciones que se me ocurrieron, que tuvieron los mejores resultados de evaluación, si alguien puede mejorarlo, 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;
}
}

• tenga en cuenta que se llama con String.toCharArray () y el resultado se puede convertir en String con el nuevo resultado de String ((char [])). La razón de esto es que, si aplica varias operaciones, puede realizarlas todas en char [] y no continuar con la conversión entre formatos. Detrás del escenario, String se almacena como char []. Si estas operaciones se incluyeran en la propia clase String, habría sido el doble de eficiente: la velocidad y la memoria.

Answer 14

Puede reducir la sobrecarga por llamada conservando los datos de relleno, en lugar de reconstruirlos cada vez que:

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 sea un parámetro para el método pad(...) . En ese caso, haga el ajuste del relleno oculto en ese método en lugar de hacerlo en el constructor.

(Sugerencia: para obtener crédito adicional, ¡hágalo seguro para la hebra!

Answer 15

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

Mostrar ''*'' para los caracteres de contraseña:

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

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

 secret123
*********

Answer 16

Sé que este hilo es un poco antiguo y la pregunta original era para una solución fácil, pero si se supone que es muy rápido, debería usar una matriz char.

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 del formateador no es óptima. simplemente construyendo la cadena de formato crea 2 nuevas cadenas.

La solución de apache se puede mejorar al inicializar la sb con el tamaño objetivo, por lo que se reemplaza a continuación

StringBuffer padded = new StringBuffer(str);

con

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

evitaría que el búfer interno de sb crezca.

Answer 17

Una solución simple sin ninguna API será la siguiente:

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 18

Una solución simple sería:

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

Answer 19

Usa 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 20

puede usar los métodos incorporados en StringBuilder append () e insert (), para rellenar 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 21

java.util.Formatter hará relleno izquierdo y derecho. No es necesario contar con dependencias impares de terceros (¿desearía agregarlas para algo tan trivial)?

[He omitido los detalles e hice esta publicación como ''wiki de la comunidad'', ya que no es algo que necesite.]

Answer 22

Algo simple:

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

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

La subcadena comienza desde el valor de índice de longitud de caracteres hasta la longitud final de rellenado:

String padded="00000000".substring(value.length()) + value;
// now padded is "00000123"

Más preciso

pad derecho

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 23

@ck de @ck ''s y @Marlon Tarak son las únicas que usan un char[] , que para las aplicaciones que tienen varias llamadas a métodos de relleno por segundo es el mejor método. Sin embargo, no aprovechan las optimizaciones de manipulación de matrices y están un poco sobrescritas a mi gusto; Esto se puede hacer sin 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 24

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

Pero tenga en cuenta que, como otros han mencionado y demostrado en esta respuesta , String.format() y las clases de Formatter en el JDK son mejores opciones. Úsalos sobre el código de los comunes.

Answer 25

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 26

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