settitle - Java: cree una nueva instancia de String con una longitud específica y rellenada con un carácter específico. ¿Mejor solución?

para que sirve settitle en java

Question

Esta pregunta ya tiene una respuesta aquí:

• Forma simple de repetir una cadena en java 29 respuestas

Revisé las otras preguntas; esta pregunta se enfoca en resolver esta pregunta en particular de la manera más eficiente.

Algunas veces quiere crear una nueva cadena con una longitud especificada, y con un carácter predeterminado llenando toda la cadena.

es decir, sería genial si pudieras hacer un new String(10, ''*'') y crear un nuevo String a partir de ahí, con una longitud de 10 caracteres todos con un *.

Debido a que dicho constructor no existe, y no puede extender desde String, tiene que crear una clase contenedora o un método para hacer esto por usted.

En este momento estoy usando esto:

protected String getStringWithLengthAndFilledWithCharacter(int length, char charToFill) {
    char[] array = new char[length];
    int pos = 0;
    while (pos < length) {
        array[pos] = charToFill;
        pos++;
    }
    return new String(array);
}

Todavía carece de control (es decir, cuando la longitud es 0 no funcionará). Estoy construyendo el conjunto primero porque creo que es más rápido que usar la concatenación de cadenas o usar un StringBuffer para hacerlo.

¿Alguien más tiene una mejor solución?

Answer 1

Algunas posibles soluciones

Esto crea una Cadena con longitudes-tiempos ''llenadas'' y reemplaza luego a ''0'' con la charToFill (vieja escuela).

String s = String.format("%0" + length + "d", 0).replace(''0'', charToFill);

Esto crea una lista que contiene longitudes de cadenas con charToFill y luego se une a la lista en una cadena.

String s = String.join("", Collections.nCopies(length, String.valueOf(charToFill)));

Esto crea un flujo java8 ilimitado con cadenas con charToFill, limita la salida a la longitud y recoge los resultados con un String joiner (nueva escuela).

String s = Stream.generate(() -> String.valueOf(charToFill)).limit(length).collect(Collectors.joining());

Answer 2

Apache Commons Lang (probablemente lo suficientemente útil como para estar en el classpath de cualquier proyecto no trivial) tiene StringUtils.repeat() :

String filled = StringUtils.repeat("*", 10);

¡Fácil!

Answer 3

En Java 11, tiene repeat :

String s = " ";
s = s.repeat(1);

(Aunque en el momento de la escritura aún está sujeto a cambios )

Answer 4

Lo anterior está bien. ¿Te importa si te hago una pregunta? ¿Esto te está causando un problema? Me parece que estás optimizando antes de saber si es necesario.

Ahora para mi solución sobre ingeniería. En muchos (no todos) los casos, puede usar CharSequence en lugar de una Cadena.

public class OneCharSequence implements CharSequence {
  private final char value;
  private final int length;
  public OneCharSequence(final char value, final int length) {
    this.value = value;
    this.length = length;
  }
  public char   charAt(int index)  {
     if(index < length) return value;
     throw new IndexOutOfBoundsException();
  }
  public int length() {
    return length;
  }
  public CharSequence subSequence(int start, int end) {
     return new OneCharSequence(value, (end-start));
  }
  public String toString() {
    char[] array = new char[length];
    Arrays.fill(array, value);
    return new String(array);
  }
}

Answer 5

Mi solución:

  pw = "1321";
    if (pw.length() < 16){
      for(int x = pw.length() ; x < 16 ; x++){
        pw  += "*";
      }
    }

La salida :

1321************

Answer 6

No es necesario hacer el ciclo y usar solo las clases de biblioteca estándar de Java:

protected String getStringWithLengthAndFilledWithCharacter(int length, char charToFill) {
  if (length > 0) {
    char[] array = new char[length];
    Arrays.fill(array, charToFill);
    return new String(array);
  }
  return "";
}

Como puede ver, también agregué el código adecuado para el caso de length == 0 .

Answer 7

Para mejorar el rendimiento, puede tener una única picadura predefinida si conoce la longitud máxima como:

String template = "####################################";

Y luego simplemente realice una subcadena una vez que sepa la longitud.

Answer 8

Prueba este jobber

String stringy =null;
 byte[] buffer =  new byte[100000];
            for (int i = 0; i < buffer.length; i++) {
            buffer[i] =0;

        }
            stringy =StringUtils.toAsciiString(buffer);

Answer 9

Pruebe esto usando la subcadena (int start, int end); método

String myLongString = "abcdefghij";
if (myLongString .length() >= 10)
String shortStr = myLongString.substring(0, 5)+ "...";

esto devolverá abcde.

Answer 10

Puede usar un ciclo while como este:

String text = "Hello";
while (text.length() < 10) { text += "*"; }
System.out.println(text);

Te regalaré:

Hello*****

O obtenga el mismo resultado con un método personalizado:

    public static String extendString(String text, String symbol, Integer len) {
        while (text.length() < len) { text += symbol; }
        return text;
    }

Entonces solo llame:

extendString("Hello", "*", 10)

También puede ser una buena idea establecer una verificación de longitud para evitar ciclos infinitos.

Answer 11

Simplemente use la clase StringUtils del proyecto lang apache commons . Tienes un método leftPad :

StringUtils.leftPad("foobar", 10, ''*''); // Returns "****foobar"

Answer 12

Solución usando Google Guava , ya que prefiero Apache Commons-Lang:

/**
 * Returns a String with exactly the given length composed entirely of
 * the given character.
 * @param length the length of the returned string
 * @param c the character to fill the String with
 */
public static String stringOfLength(final int length, final char c)
{
    return Strings.padEnd("", length, c);
}

Answer 13

Solución usando Google Guava

String filled = Strings.repeat("*", 10);

Answer 14

Una nota adicional: parece que todas las formas públicas de crear una nueva instancia de String implica necesariamente la copia de cualquier búfer con la que esté trabajando, ya sea un char[] , un StringBuffer o un StringBuilder . Desde el String javadoc (y se repite en los métodos toString respectivos de las otras clases):

El contenido de la matriz de caracteres se copia; la modificación posterior de la matriz de caracteres no afecta a la cadena recién creada.

Entonces terminará teniendo una operación de copia de memoria posiblemente grande después del "llenado rápido" de la matriz. La única solución que puede evitar este problema es la de @mlk, si puede gestionar el trabajo directamente con la implementación CharSequence propuesta (lo que puede ser el caso).

PD: Publicaría esto como un comentario, pero aún no tengo suficiente reputación para hacerlo.

Answer 15

usar Dollar es simple:

String filled = $("=").repeat(10).toString(); // produces "=========="

Answer 16

char[] chars = new char[10];
Arrays.fill(chars, ''*'');
String text = new String(chars);

Answer 17

public static String fillString(int count,char c) {
    StringBuilder sb = new StringBuilder( count );
    for( int i=0; i<count; i++ ) {
        sb.append( c ); 
    }
    return sb.toString();
}

¿Qué está mal?