Apakah ada cara di java untuk membuat string dengan jumlah karakter yang ditentukan? Dalam kasus saya, saya perlu membuat string dengan 10 spasi. Kode saya saat ini adalah:

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

Apakah ada cara yang lebih baik untuk mencapai hal yang sama. Khususnya saya suka sesuatu yang cepat (dalam hal eksekusi).

For loop akan dioptimalkan oleh kompiler. Dalam kasus seperti ini, Anda tidak perlu peduli tentang pengoptimalan sendiri. Percayai kompiler.

BTW, jika ada cara untuk membuat string dengan karakter n spasi, daripada dikodekan dengan cara yang sama seperti yang baru saja Anda lakukan.

Kemungkinan kode terpendek menggunakan StringAPI, secara eksklusif:

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

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

Sebagai metode, tanpa langsung membuat contoh 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', ' ' );
}

Meminta menggunakan:

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

Hmm sekarang saya memikirkannya, mungkin Arrays.fill:

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

Tentu saja, saya berasumsi bahwa fillmetode ini melakukan hal yang sama dengan kode Anda, jadi mungkin akan melakukan hal yang sama, tetapi setidaknya ini lebih sedikit baris.

Saya sangat menyarankan untuk tidak menulis loop dengan tangan. Anda akan melakukannya berulang kali selama karir pemrograman Anda. Orang-orang yang membaca kode Anda - termasuk Anda - selalu harus menginvestasikan waktu, meskipun hanya beberapa detik, untuk mencerna makna dari loop tersebut.

Alih-alih menggunakan kembali salah satu pustaka yang tersedia yang menyediakan kode seperti itu StringUtils.repeatdari Apache Commons Lang :

StringUtils.repeat(' ', length);

Dengan begitu Anda juga tidak perlu repot tentang kinerja, sehingga semua detail mengerikan StringBuilder, optimisasi Kompiler dll. Disembunyikan. Jika fungsinya akan menjadi lambat itu akan menjadi bug dari perpustakaan.

Dengan Java 11 menjadi lebih mudah:

" ".repeat(length);

Di Java 8 Anda dapat menggunakan String.join:

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

Jika Anda hanya ingin spasi, lalu bagaimana:

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

yang akan menghasilkan abs (n) spasi;

sejak Jawa 11 :

" ".repeat(10);

sejak Java 8 :

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

dimana:

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

Karena Java 11, Anda cukup menggunakan String.repeat(count)untuk menyelesaikan masalah Anda.

Mengembalikan string yang nilainya merupakan rangkaian string ini diulangi count kali.

Jika string ini kosong atau countnol maka string kosong dikembalikan.

Jadi alih-alih loop, kode Anda hanya akan terlihat seperti ini:

" ".repeat(length);

Saya pikir ini adalah kode yang kurang mungkin, menggunakan kelas Guava Joiner:

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

Anda dapat menggunakan String.formatfungsi standar untuk menghasilkan spasi N. Sebagai contoh:

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

Membuat string dengan 5 spasi.

atau

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

Membuat string 15 spacebars.

Jika Anda ingin simbol lain diulang, Anda harus mengganti spasi dengan simbol yang Anda inginkan:

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

Keluaran:

#######

Kontribusi saya berdasarkan algoritma eksponensial cepat.

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

Saya menguji algoritma terhadap dua pendekatan lain:

• Biasa untuk loop menggunakan String.concat()untuk menyatukan string
• Biasa untuk loop menggunakan a StringBuilder

Kode uji (gabungan menggunakan for loop dan String.concat()menjadi lambat untuk besar n, jadi saya meninggalkannya setelah iterasi ke-5).

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

Hasil:

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

Kesimpulan:

• Untuk yang besar n- gunakan pendekatan rekursif
• Untuk kecil n- untuk loop memiliki kecepatan yang cukup

Bagaimana dengan ini?

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

Mengingat kami memiliki:

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 (Menggunakan Stream)

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

Java 8 (Menggunakan nCopies)

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

RandomStringUtils memiliki ketentuan untuk membuat string dari ukuran input yang diberikan. Tidak dapat mengomentari kecepatan, tetapi satu liner.

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

menciptakan output

\ t \ t \ t \ t \ t

lebih disukai jika Anda tidak ingin melihat \ 0 dalam kode Anda.

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

Dalam kebanyakan kasus, Anda hanya membutuhkan string hingga panjang tertentu, katakanlah 100 spasi. Anda bisa menyiapkan larik String di mana nomor indeks sama dengan ukuran string yang diisi spasi dan mencari string, jika panjang yang dibutuhkan berada dalam batas atau membuatnya sesuai permintaan jika di luar batas.

Solusi terpendek dengan Jambu Biji:

Strings.repeat(" ", len)

Melalui cara sederhana untuk mengulang String di java .

Cukup ganti StringBuffer Anda dengan StringBuilder . Sulit untuk mengalahkannya.

Jika panjang Anda adalah jumlah yang besar, Anda dapat menerapkan beberapa penambahan sendiri yang lebih efisien (tapi lebih canggung), menduplikasi panjangnya di setiap iterasi:

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

Anda juga dapat mencoba Arrays.fill()pendekatan tersebut ( FrustratedWithFormsDesigner jawaban).

Anda bisa menggantinya StringBufferdenganStringBuilder (yang terakhir tidak disinkronkan, mungkin lebih cepat dalam satu aplikasi utas)

Dan Anda dapat membuat StringBuilderinstance satu kali, alih-alih membuatnya setiap kali Anda membutuhkannya.

Sesuatu seperti ini:

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

  }

Dan gunakan seperti ini:

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

Jika Anda menganggap createAvariabel Anda sebagai instance, Anda dapat menghemat waktu membuat instance.

Ini bukan utas aman, jika Anda memiliki banyak utas, setiap utas harus memiliki salinannya sendiri.

Untuk kinerja yang baik, gabungkan jawaban dari aznilamir dan dari FrustratedWithFormsDesigner

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

Sesuaikan ukuran BLANKStergantung pada kebutuhan Anda. BLANKSString spesifik saya sekitar 200 karakter.

Punya metode seperti ini. Ini menambahkan ruang yang dibutuhkan pada akhir yang diberikan Stringuntuk memberikan Stringpanjang tertentu.

public static String fillSpaces (String str) {

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

Ingin String memiliki ukuran tetap, sehingga Anda dapat membalut atau memotong, untuk mentabulasi data ...

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|

Referensi yang sangat baik di sini .

Ini berhasil bagi saya tanpa menggunakan perpustakaan eksternal di Java 8

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

Dan hasilnya

testtesttest

int c = 10; String spasi = String.format ("%" + c + "c", ''); ini akan menyelesaikan masalah Anda.

Metode sederhana seperti di bawah ini juga dapat digunakan

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

bagaimana dengan ini?

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

EDIT: Saya sudah menulis kode sederhana untuk menguji konsep dan di sini apa yang saya temukan.

Metode 1: menambahkan ruang tunggal dalam satu lingkaran:

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

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

    return sb.toString();
  }

Metode 2: tambahkan 100 spasi dan loop, lalu substring:

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

Hasilnya saya dapat membuat 12.345.678 spasi:

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

dan untuk 10.000.000 ruang:

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

menggabungkan alokasi langsung dan iterasi selalu membutuhkan waktu lebih sedikit, rata-rata 60 ms lebih sedikit ketika membuat ruang besar. Untuk ukuran yang lebih kecil, kedua hasilnya dapat diabaikan.

Tapi tolong terus berkomentar :-)

Saya tahu tidak ada metode bawaan untuk apa yang Anda tanyakan. Namun, untuk panjang tetap kecil seperti 10, metode Anda harus cepat.