Java – Maak een nieuwe String-instantie met een opgegeven lengte en gevuld met een specifiek teken. Beste oplossing?

Ik heb de andere vragen gecontroleerd; deze vraag is gericht op het oplossen van deze specifieke vraag op de meest efficiënte manier.

Soms wil je een nieuwe tekenreeks maken met een opgegeven lengte en met een standaardteken dat de hele tekenreeks vult.

Het zou cool zijn als je new String(10, '*')zou kunnen doen en van daaruit een nieuwe String zou maken, met een lengte van 10 tekens die allemaal een * hebben.

Omdat zo’n constructor niet bestaat en je niet kunt uitbreiden vanuit String, moet je ofwel een wrapper-klasse of een methode maken om dit voor je te doen.

Op dit moment gebruik ik dit:

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

Er is nog steeds geen controle (dwz als de lengte 0 is, werkt het niet). Ik bouw eerst de array omdat ik denk dat het sneller is dan het gebruik van stringconcatination of het gebruik van een StringBuffer om dit te doen.

Heeft iemand anders een betere oplossing?

Antwoord 1, autoriteit 100%

Apache Commons Lang (waarschijnlijk handig genoeg om op het klassenpad van een niet-triviaal project te staan) heeft StringUtils.repeat():

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

Eenvoudig!

Antwoord 2, autoriteit 79%

Gebruik gewoon de StringUtils-klasse van het apache commons lang-project. Je hebt een leftPadmethode:

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

Antwoord 3, autoriteit 45%

Het is niet nodig om de lus te maken en alleen standaard Java-bibliotheekklassen te gebruiken:

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

Zoals je kunt zien, heb ik ook geschikte code toegevoegd voor het geval length == 0.

Antwoord 4, autoriteit 30%

Enkele mogelijke oplossingen.

Dit creëert een String met lengte-tijden ‘0’ gevuld en vervangt dan de ‘0’ door de charToFill (old school).

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

Hiermee wordt een lijst gemaakt met strings van lange duur met charToFill en voegt u de lijst vervolgens samen tot een string.

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

Dit creëert een onbeperkte java8-stream met strings met charToFill, beperkt de uitvoer tot lengte en verzamelt de resultaten met een String-joiner (nieuwe school).

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

Antwoord 5, autoriteit 20%

In Java 11 heb je repeat:

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

(Hoewel op het moment van schrijven nog steeds onderhevig aan wijzigen)

6, Autoriteit 6%

Om de prestaties te verbeteren kun je een enkel vooraf bepaald steek hebben als je de maximale lengte als te weten:

String template = “####################################”;

En dan gewoon een substring te voeren zodra u de lengte weten.

Antwoord 7

Mi oplossing:

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

De uitvoer:

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

Antwoord 8

Probeer deze jobber

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