Java'da belirtilen sayıda belirtilen karaktere sahip bir dize oluşturmanın bir yolu var mı? Benim durumumda, 10 boşluklu bir dize oluşturmak gerekir. Geçerli kodum:

StringBuffer outputBuffer = new StringBuffer(length);
for (int i = 0; i < length; i++){
   outputBuffer.append(" ");
}
return outputBuffer.toString();

Aynı şeyi başarmanın daha iyi bir yolu var mı? Özellikle hızlı (idam açısından) bir şey rica ediyorum.

For döngüsü derleyici tarafından optimize edilir. Sizinki gibi durumlarda, optimizasyonu tek başınıza yapmanız gerekmez. Derleyiciye güvenin.

BTW, n boşluk karakterli bir dize oluşturmanın bir yolu varsa, tıpkı sizin yaptığınız gibi kodlandığından daha fazladır.

StringAPI'yi kullanan muhtemelen en kısa kod :

String space10 = new String(new char[10]).replace('\0', ' ');

System.out.println("[" + space10 + "]");
// prints "[          ]"

Bir yöntem olarak, doğrudan somutlaştırmadan char:

import java.nio.CharBuffer;

/**
 * Creates a string of spaces that is 'spaces' spaces long.
 *
 * @param spaces The number of spaces to add to the string.
 */
public String spaces( int spaces ) {
  return CharBuffer.allocate( spaces ).toString().replace( '\0', ' ' );
}

Şunu kullanarak çağır:

System.out.printf( "[%s]%n", spaces( 10 ) );

Hmm şimdi düşünüyorum, belki Arrays.fill:

char[] charArray = new char[length];
Arrays.fill(charArray, ' ');
String str = new String(charArray);

Tabii ki, fillyöntemin kodunuzla aynı şeyi yaptığını varsayıyorum , bu yüzden muhtemelen yaklaşık aynı performansı gösterecektir, ancak en azından bu daha az satırdır.

Döngüyü elle yazmamanızı şiddetle tavsiye ederim. Programlama kariyeriniz boyunca bunu tekrar tekrar yapacaksınız. Kodunuzu okuyan - sizi de içeren insanlar - sadece birkaç saniye olsa bile, döngünün anlamını sindirmek için zaman harcamak zorundadır.

Bunun yerine , Apache Commons Lang'da olduğu gibi kod sağlayan mevcut kitaplıklardan birini yeniden kullanın :StringUtils.repeat

StringUtils.repeat(' ', length);

Bu şekilde performansla uğraşmak zorunda kalmazsınız, bu nedenle StringBuilderDerleyici optimizasyonları vb. Eğer fonksiyon yavaşça ortaya çıkarsa kütüphane hatası olur.

Java 11 ile daha da kolaylaşır:

" ".repeat(length);

Java 8'de şunları kullanabilirsiniz String.join:

String.join("", Collections.nCopies(n, s));

Sadece boşluk istiyorsanız, o zaman:

String spaces = (n==0)?"":String.format("%"+n+"s", "");

abs (n) boşlukları ile sonuçlanacak;

Java 11'den beri :

" ".repeat(10);

Java 8'den beri :

generate(() -> " ").limit(10).collect(joining());

nerede:

import static java.util.stream.Collectors.joining;
import static java.util.stream.Stream.generate;

Java 11'den beri String.repeat(count)sorununuzu çözmek için kullanabilirsiniz .

Değeri bu dizenin tekrarlanan countkez birleşimi olan bir dize döndürür .

Bu dize boşsa veya countsıfırsa, boş dize döndürülür.

Yani bir döngü yerine kodunuz şöyle görünecektir:

" ".repeat(length);

Bu mümkün daha az kod olduğunu düşünüyorum, Guava Joiner sınıfı kullanır:

Joiner .on (""). Join ( Collections.nCopies (10, ""));

String.formatN boşluk oluşturmak için standart işlevi kullanabilirsiniz . Örneğin:

String.format("%5c", ' ');

5 boşluklu bir dize oluşturur.

veya

int count = 15;
String fifteenSpacebars = String.format("%" + count + "c", ' ');

15 ara çubuğu dizesi yapar.

Başka bir sembolün tekrarlanmasını istiyorsanız, boşlukları istediğiniz sembolle değiştirmeniz gerekir:

int count = 7;
char mySymbol = '#';
System.out.println(String.format("%" + count + "c", ' ').replaceAll("\\ ", "\\" + mySymbol));

Çıktı:

#######

Katkılarım hızlı üs alma algoritmasına dayanıyor.

/**
 * Repeats the given {@link String} n times.
 * 
 * @param str
 *            the {@link String} to repeat.
 * @param n
 *            the repetition count.
 * @throws IllegalArgumentException
 *             when the given repetition count is smaller than zero.
 * @return the given {@link String} repeated n times.
 */
public static String repeat(String str, int n) {
    if (n < 0)
        throw new IllegalArgumentException(
                "the given repetition count is smaller than zero!");
    else if (n == 0)
        return "";
    else if (n == 1)
        return str;
    else if (n % 2 == 0) {
        String s = repeat(str, n / 2);
        return s.concat(s);
    } else
        return str.concat(repeat(str, n - 1));
}

Algoritmayı diğer iki yaklaşıma karşı test ettim:

• String.concat()Dizeyi bitiştirirken döngü kullanımı için düzenli
• Bir kullanarak döngü için düzenli StringBuilder

Test kodu (for döngüsü kullanarak birleştirme ve String.concat()büyük için yavaş olur n, bu yüzden 5. yinelemeden sonra dışarıda bıraktım).

/**
 * Test the string concatenation operation.
 * 
 * @param args
 */
public static void main(String[] args) {
    long startTime;
    String str = " ";

    int n = 1;
    for (int j = 0; j < 9; ++j) {
        n *= 10;
        System.out.format("Performing test with n=%d\n", n);

        startTime = System.currentTimeMillis();
        StringUtil.repeat(str, n);
        System.out
                .format("\tStringUtil.repeat() concatenation performed in    %d milliseconds\n",
                        System.currentTimeMillis() - startTime);

        if (j <5) {
            startTime = System.currentTimeMillis();
            String string = "";
            for (int i = 0; i < n; ++i)
                string = string.concat(str);
            System.out
                    .format("\tString.concat() concatenation performed in        %d milliseconds\n",
                            System.currentTimeMillis() - startTime);
        } else
            System.out
                    .format("\tString.concat() concatenation performed in        x milliseconds\n");
        startTime = System.currentTimeMillis();
        StringBuilder b = new StringBuilder();
        for (int i = 0; i < n; ++i)
            b.append(str);
        b.toString();
        System.out
                .format("\tStringBuilder.append() concatenation performed in %d milliseconds\n",
                        System.currentTimeMillis() - startTime);
    }
}

Sonuçlar:

Performing test with n=10
    StringUtil.repeat() concatenation performed in    0 milliseconds
    String.concat() concatenation performed in        0 milliseconds
    StringBuilder.append() concatenation performed in 0 milliseconds
Performing test with n=100
    StringUtil.repeat() concatenation performed in    0 milliseconds
    String.concat() concatenation performed in        1 milliseconds
    StringBuilder.append() concatenation performed in 0 milliseconds
Performing test with n=1000
    StringUtil.repeat() concatenation performed in    0 milliseconds
    String.concat() concatenation performed in        1 milliseconds
    StringBuilder.append() concatenation performed in 1 milliseconds
Performing test with n=10000
    StringUtil.repeat() concatenation performed in    0 milliseconds
    String.concat() concatenation performed in        43 milliseconds
    StringBuilder.append() concatenation performed in 5 milliseconds
Performing test with n=100000
    StringUtil.repeat() concatenation performed in    0 milliseconds
    String.concat() concatenation performed in        1579 milliseconds
    StringBuilder.append() concatenation performed in 1 milliseconds
Performing test with n=1000000
    StringUtil.repeat() concatenation performed in    0 milliseconds
    String.concat() concatenation performed in        x milliseconds
    StringBuilder.append() concatenation performed in 10 milliseconds
Performing test with n=10000000
    StringUtil.repeat() concatenation performed in    7 milliseconds
    String.concat() concatenation performed in        x milliseconds
    StringBuilder.append() concatenation performed in 112 milliseconds
Performing test with n=100000000
    StringUtil.repeat() concatenation performed in    80 milliseconds
    String.concat() concatenation performed in        x milliseconds
    StringBuilder.append() concatenation performed in 1107 milliseconds
Performing test with n=1000000000
    StringUtil.repeat() concatenation performed in    1372 milliseconds
    String.concat() concatenation performed in        x milliseconds
    StringBuilder.append() concatenation performed in 12125 milliseconds

Sonuç:

• Büyük için n- özyinelemeli yaklaşımı kullanın
• Küçük için n- döngü için yeterli hız var

Buna ne dersin?

char[] bytes = new char[length];
Arrays.fill(bytes, ' ');
String str = new String(bytes);

Elimizde:

String c = "c"; // character to repeat, for empty it would be " ";
int n = 4; // number of times to repeat
String EMPTY_STRING = ""; // empty string (can be put in utility class)

Java 8 (Akışı Kullanma)

String resultOne = IntStream.range(0,n)
   .mapToObj(i->c).collect(Collectors.joining(EMPTY_STRING)); // cccc

Java 8 (nCopies Kullanarak)

String resultTwo = String.join(EMPTY_STRING, Collections.nCopies(n, c)); //cccc

RandomStringUtils , belirtilen girdi boyutundan bir dize oluşturma özelliğine sahiptir. Hız yorum yapamam, ama onun bir astar.

RandomStringUtils.random(5,"\t");

çıktı oluşturur

\ \ T \ t \ t \ t

kodunuzda \ 0 görmek istemiyorsanız tercih edilir .

StringUtils Kullan: StringUtils.repeat ('', 10)

Çoğu durumda, 100 boşluk gibi belirli bir uzunluktaki dizelere ihtiyacınız vardır. Dizin sayısının boşlukla doldurulmuş dizenin boyutuna eşit olduğu bir Dizeler dizisi hazırlayabilir ve gerekli uzunluk sınırlar dahilindeyse dizeyi arayabilir veya sınırın dışındaysa istek üzerine oluşturabilirsiniz.

Guava ile en kısa çözüm:

Strings.repeat(" ", len)

Via Basit bir şekilde java bir dize tekrarlamak .

StringBuffer'ınızı bir StringBuilder ile değiştirin . Bunu yenmek zor.

Uzunluğunuz büyük bir sayı ise, her bir yinelemede uzunluğu çoğaltarak daha verimli (ancak daha sakar) kendi kendine ekleme uygulayabilirsiniz:

 public static String dummyString(char c, int len) {
  if( len < 1 ) return "";
  StringBuilder sb = new StringBuilder(len).append(c);
  int remnant = len - sb.length();
  while(remnant  > 0) {
   if( remnant  >= sb.length() ) sb.append(sb);
   else sb.append(sb.subSequence(0, remnant));
   remnant  = len - sb.length();
  }
  return sb.toString();
 }

Ayrıca, Arrays.fill()yaklaşımı deneyebilirsiniz ( FrustratedWithFormsDesigner'ın yanıtı).

Sen yerini alabilir StringBufferile StringBuilder(ikincisi senkronize edilmedi; daha hızlı bir tek iplik uygulamasında olabilir)

Ve oluşturabileceğiniz StringBuilderyerine Eğer ihtiyacınız her zaman yaratma, bir kez örneği.

Bunun gibi bir şey:

class BuildString {
     private final StringBuilder builder = new StringBuilder();
     public String stringOf( char c , int times ) {

         for( int i = 0 ; i < times ; i++  ) {
             builder.append( c );
         }
         String result = builder.toString();
         builder.delete( 0 , builder.length() -1 );
         return result;
      }

  }

Ve şu şekilde kullanın:

 BuildString createA = new BuildString();
 String empty = createA.stringOf( ' ', 10 );

Öğenizi createAörnek değişkeni olarak tutarsanız, örnek oluştururken zaman kazanabilirsiniz.

Bu iş parçacığı için güvenli değildir, çoklu iş parçacıklarınız varsa, her iş parçacığının kendi kopyası olmalıdır.

İyi performans için aznilamir ve FrustratedWithFormsDesigner'ın yanıtlarını birleştirin

private static final String BLANKS = "                       ";
private static String getBlankLine( int length )
{
    if( length <= BLANKS.length() )
    {
        return BLANKS.substring( 0, length );
    }
    else
    {
        char[] array = new char[ length ];
        Arrays.fill( array, ' ' );
        return new String( array );
    }
}

BLANKSİhtiyaçlarınıza göre boyutunu ayarlayın . Özel BLANKSdizem yaklaşık 200 karakter uzunluğunda.

Böyle bir yöntem var. Bu , belirli bir uzunlukta uzunluk Stringvermek için verilenin sonuna gerekli boşlukları ekler String.

public static String fillSpaces (String str) {

    // the spaces string should contain spaces exceeding the max needed
    String spaces = "                                                   ";
    return str + spaces.substring(str.length());
}

Dize'nin sabit boyutta olmasını istediğinizden, verileri tablolamak için ped veya kısaltmayı kullanın ...

class Playground {
    private static String fixStrSize(String s, int n) {
        return String.format("%-" + n + "s", String.format("%." + n +"s", s));
    }

    public static void main(String[ ] args) {
        System.out.println("|"+fixStrSize("Hell",8)+"|");
        System.out.println("|"+fixStrSize("Hells Bells Java Smells",8)+"|");
    }
}

|Hell    |
|Hells Be|

Mükemmel referans burada .

Bu, Java 8'de herhangi bir harici kitaplık kullanmadan benim için çalıştı

String sampleText = "test"
int n = 3;
String output = String.join("", Collections.nCopies(n, sampleText));
System.out.println(output);

Ve çıktı

testtesttest

int c = 10; Dize boşlukları = String.format ("%" + c + "c", ''); Bu sorununu çözecektir.

Aşağıdaki gibi basit bir yöntem de kullanılabilir

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

buna ne dersin?

public String fillSpaces(int len) {
    /* the spaces string should contain spaces exceeding the max needed */  
    String spaces = "                                                   ";
    return spaces.substring(0,len);
}

EDIT: Ben kavram ve burada ne buldum test etmek için basit bir kod yazdım.

Yöntem 1: bir döngüde tek boşluk ekleme:

  public String execLoopSingleSpace(int len){
    StringBuilder sb = new StringBuilder();

    for(int i=0; i < len; i++) {
        sb.append(' ');
    }

    return sb.toString();
  }

Yöntem 2: 100 boşluk ve döngü ekleyin, ardından alt dize:

  public String execLoopHundredSpaces(int len){
    StringBuilder sb = new StringBuilder("          ")
            .append("          ").append("          ").append("          ")
            .append("          ").append("          ").append("          ")
            .append("          ").append("          ").append("          ");

    for (int i=0; i < len/100 ; i++) {
        sb.append("          ")
            .append("          ").append("          ").append("          ")
            .append("          ").append("          ").append("          ")
            .append("          ").append("          ").append("          ");
    }

    return sb.toString().substring(0,len);
  }

12.345.678 boşluk oluşturduğum sonuç:

C:\docs\Projects> java FillSpace 12345678
method 1: append single spaces for 12345678 times. Time taken is **234ms**. Length of String is 12345678
method 2: append 100 spaces for 123456 times. Time taken is **141ms**. Length of String is 12345678
Process java exited with code 0

ve 10.000.000 alan için:

C:\docs\Projects> java FillSpace 10000000
method 1: append single spaces for 10000000 times. Time taken is **157ms**. Length of String is 10000000
method 2: append 100 spaces for 100000 times. Time taken is **109ms**. Length of String is 10000000
Process java exited with code 0

Doğrudan ayırma ve yinelemeyi birleştirmek, büyük alanlar oluştururken her zaman daha az zaman, ortalama 60 ms daha az zaman alır. Daha küçük boyutlar için her iki sonuç da ihmal edilebilir.

Ama lütfen yorum yapmaya devam edin :-)

Sorduğunuz şey için yerleşik bir yöntem bilmiyorum. Bununla birlikte, 10 gibi küçük bir sabit uzunluk için, yönteminiz çok hızlı olmalıdır.