Rangkaian string: concat () vs operator "+"

Dengan asumsi String a dan b:

a += b
a = a.concat(b)

Di bawah tenda, apakah mereka hal yang sama?

Di sini concat didekompilasi sebagai referensi. Saya ingin dapat mendekompilasi +operator juga untuk melihat apa yang dilakukannya.

public String concat(String s) {

    int i = s.length();
    if (i == 0) {
        return this;
    }
    else {
        char ac[] = new char[count + i];
        getChars(0, count, ac, 0);
        s.getChars(0, i, ac, count);
        return new String(0, count + i, ac);
    }
}

Tidak, tidak cukup.

Pertama, ada sedikit perbedaan dalam semantik. Jika aini null, maka a.concat(b)melemparkan NullPointerExceptiontetapi a+=bakan memperlakukan nilai asli aseolah-olah itu null. Selain itu, concat()metode ini hanya menerima Stringnilai sementara +operator akan secara diam-diam mengubah argumen menjadi String (menggunakan toString()metode untuk objek). Sehinggaconcat() metode ini lebih ketat dalam apa yang diterimanya.

Untuk melihat di bawah tenda, tulis kelas sederhana dengan a += b;

public class Concat {
    String cat(String a, String b) {
        a += b;
        return a;
    }
}

Sekarang dibongkar dengan javap -c(termasuk dalam Sun JDK). Anda akan melihat daftar termasuk:

java.lang.String cat(java.lang.String, java.lang.String);
  Code:
   0:   new     #2; //class java/lang/StringBuilder
   3:   dup
   4:   invokespecial   #3; //Method java/lang/StringBuilder."<init>":()V
   7:   aload_1
   8:   invokevirtual   #4; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   11:  aload_2
   12:  invokevirtual   #4; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   15:  invokevirtual   #5; //Method java/lang/StringBuilder.toString:()Ljava/lang/    String;
   18:  astore_1
   19:  aload_1
   20:  areturn

Jadi, a += bsama dengan

a = new StringBuilder()
    .append(a)
    .append(b)
    .toString();

The concatmetode harus lebih cepat. Namun, dengan lebih banyak stringStringBuilder metode ini menang, setidaknya dalam hal kinerja.

Kode sumber Stringdan StringBuilder(dan kelas dasar paket-privasinya) tersedia di src.zip dari Sun JDK. Anda dapat melihat bahwa Anda sedang membangun array char (mengubah ukuran sesuai kebutuhan) dan kemudian membuangnya ketika Anda membuat final String. Dalam praktiknya alokasi memori sangat cepat.

Pembaruan: Seperti catatan Pawel Adamski, kinerja telah berubah di HotSpot yang lebih baru. javacmasih menghasilkan kode yang persis sama, tetapi kode curang bytecode. Pengujian sederhana sepenuhnya gagal karena seluruh badan kode dibuang. Penjumlahan System.identityHashCode(tidak String.hashCode) menunjukkan StringBufferkode memiliki sedikit keuntungan. Dapat berubah ketika pembaruan berikutnya dirilis, atau jika Anda menggunakan JVM yang berbeda. Dari @lukaseder , daftar intrinsik HotSpot JVM .

Niyaz benar, tetapi perlu juga dicatat bahwa operator + khusus dapat dikonversi menjadi sesuatu yang lebih efisien oleh kompiler Java. Java memiliki kelas StringBuilder yang mewakili String yang tidak dapat diubah, aman, dapat diubah. Saat melakukan sekelompok rangkaian String, kompiler Java secara diam-diam mengonversi

String a = b + c + d;

ke

String a = new StringBuilder(b).append(c).append(d).toString();

yang untuk string besar secara signifikan lebih efisien. Sejauh yang saya tahu, ini tidak terjadi ketika Anda menggunakan metode concat.

Namun, metode concat lebih efisien ketika menggabungkan String kosong ke String yang ada. Dalam hal ini, JVM tidak perlu membuat objek String baru dan cukup mengembalikan yang sudah ada. Lihat dokumentasi concat untuk mengonfirmasi hal ini.

Jadi, jika Anda sangat memperhatikan efisiensi maka Anda harus menggunakan metode concat saat menggabungkan string-string yang mungkin kosong, dan gunakan + sebaliknya. Namun, perbedaan kinerja harus diabaikan dan Anda mungkin tidak perlu khawatir tentang hal ini.

Saya menjalankan tes serupa dengan @marcio tetapi dengan loop berikut sebagai gantinya:

String c = a;
for (long i = 0; i < 100000L; i++) {
    c = c.concat(b); // make sure javac cannot skip the loop
    // using c += b for the alternative
}

Hanya untuk ukuran yang baik, saya juga melempar StringBuilder.append(). Setiap tes dijalankan 10 kali, dengan 100rb repetisi untuk setiap putaran. Inilah hasilnya:

• StringBuildermenang telak. Hasil jam waktu adalah 0 untuk sebagian besar berjalan, dan yang paling lama mengambil 16ms.
• a += b membutuhkan sekitar 40000 ms (40 detik) untuk setiap proses.
• concat hanya membutuhkan 10000ms (10s) per run.

Saya belum mendekompilasi kelas untuk melihat internal atau menjalankannya melalui profiler, tapi saya curiga a += bmenghabiskan banyak waktu membuat objek baru StringBuilderdan kemudian mengubahnya kembali String.

Sebagian besar jawaban di sini berasal dari 2008. Tampaknya banyak hal telah berubah dari waktu ke waktu. Benchmark terbaru saya yang dibuat dengan JMH menunjukkan bahwa di Java 8 +sekitar dua kali lebih cepat daripada concat.

Tolok ukur saya:

@Warmup(iterations = 5, time = 200, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 5, time = 200, timeUnit = TimeUnit.MILLISECONDS)
public class StringConcatenation {

    @org.openjdk.jmh.annotations.State(Scope.Thread)
    public static class State2 {
        public String a = "abc";
        public String b = "xyz";
    }

    @org.openjdk.jmh.annotations.State(Scope.Thread)
    public static class State3 {
        public String a = "abc";
        public String b = "xyz";
        public String c = "123";
    }


    @org.openjdk.jmh.annotations.State(Scope.Thread)
    public static class State4 {
        public String a = "abc";
        public String b = "xyz";
        public String c = "123";
        public String d = "!@#";
    }

    @Benchmark
    public void plus_2(State2 state, Blackhole blackhole) {
        blackhole.consume(state.a+state.b);
    }

    @Benchmark
    public void plus_3(State3 state, Blackhole blackhole) {
        blackhole.consume(state.a+state.b+state.c);
    }

    @Benchmark
    public void plus_4(State4 state, Blackhole blackhole) {
        blackhole.consume(state.a+state.b+state.c+state.d);
    }

    @Benchmark
    public void stringbuilder_2(State2 state, Blackhole blackhole) {
        blackhole.consume(new StringBuilder().append(state.a).append(state.b).toString());
    }

    @Benchmark
    public void stringbuilder_3(State3 state, Blackhole blackhole) {
        blackhole.consume(new StringBuilder().append(state.a).append(state.b).append(state.c).toString());
    }

    @Benchmark
    public void stringbuilder_4(State4 state, Blackhole blackhole) {
        blackhole.consume(new StringBuilder().append(state.a).append(state.b).append(state.c).append(state.d).toString());
    }

    @Benchmark
    public void concat_2(State2 state, Blackhole blackhole) {
        blackhole.consume(state.a.concat(state.b));
    }

    @Benchmark
    public void concat_3(State3 state, Blackhole blackhole) {
        blackhole.consume(state.a.concat(state.b.concat(state.c)));
    }


    @Benchmark
    public void concat_4(State4 state, Blackhole blackhole) {
        blackhole.consume(state.a.concat(state.b.concat(state.c.concat(state.d))));
    }
}

Hasil:

Benchmark                             Mode  Cnt         Score         Error  Units
StringConcatenation.concat_2         thrpt   50  24908871.258 ± 1011269.986  ops/s
StringConcatenation.concat_3         thrpt   50  14228193.918 ±  466892.616  ops/s
StringConcatenation.concat_4         thrpt   50   9845069.776 ±  350532.591  ops/s
StringConcatenation.plus_2           thrpt   50  38999662.292 ± 8107397.316  ops/s
StringConcatenation.plus_3           thrpt   50  34985722.222 ± 5442660.250  ops/s
StringConcatenation.plus_4           thrpt   50  31910376.337 ± 2861001.162  ops/s
StringConcatenation.stringbuilder_2  thrpt   50  40472888.230 ± 9011210.632  ops/s
StringConcatenation.stringbuilder_3  thrpt   50  33902151.616 ± 5449026.680  ops/s
StringConcatenation.stringbuilder_4  thrpt   50  29220479.267 ± 3435315.681  ops/s

Tom benar dalam menggambarkan apa yang dilakukan operator +. Itu menciptakan sementara StringBuilder, menambahkan bagian-bagian, dan selesai dengan toString().

Namun, semua jawaban sejauh ini mengabaikan efek dari optimasi runtime HotSpot. Secara khusus, operasi sementara ini diakui sebagai pola umum dan diganti dengan kode mesin yang lebih efisien saat dijalankan.

@marcio: Anda telah membuat tolok ukur mikro ; dengan JVM modern ini bukan cara yang valid untuk kode profil.

Alasan mengapa run-time optimasi penting adalah karena banyak perbedaan dalam kode ini - bahkan termasuk pembuatan objek - benar-benar berbeda ketika HotSpot berjalan. Satu-satunya cara untuk mengetahui dengan pasti adalah membuat profil kode Anda di tempat .

Akhirnya, semua metode ini sebenarnya sangat cepat. Ini mungkin merupakan kasus optimasi prematur. Jika Anda memiliki kode yang banyak merangkai string, cara untuk mendapatkan kecepatan maksimum mungkin tidak ada hubungannya dengan operator mana yang Anda pilih dan alih-alih algoritma yang Anda gunakan!

Bagaimana dengan beberapa pengujian sederhana? Gunakan kode di bawah ini:

long start = System.currentTimeMillis();

String a = "a";

String b = "b";

for (int i = 0; i < 10000000; i++) { //ten million times
     String c = a.concat(b);
}

long end = System.currentTimeMillis();

System.out.println(end - start);

• The "a + b"Versi dieksekusi di 2500ms .
• The a.concat(b)dieksekusi di 1200ms .

Diuji beberapa kali. The concat()eksekusi Versi mengambil setengah dari waktu rata-rata.

Hasil ini mengejutkan saya karena concat()metode ini selalu menciptakan string baru (mengembalikan " new String(result)". Sudah diketahui bahwa:

String a = new String("a") // more than 20 times slower than String a = "a"

Mengapa kompiler tidak dapat mengoptimalkan pembuatan string dalam kode "a + b", mengetahui bahwa selalu menghasilkan string yang sama? Itu bisa menghindari pembuatan string baru. Jika Anda tidak percaya dengan pernyataan di atas, ujilah diri Anda.

Pada dasarnya, ada dua perbedaan penting antara + dan concatmetode.

1. Jika Anda menggunakan metode concat maka Anda hanya akan dapat menggabungkan string sementara dalam kasus operator + , Anda juga dapat menggabungkan string dengan tipe data apa pun.

   Sebagai contoh:

   String s = 10 + "Hello";

   Dalam hal ini, outputnya harus 10Halo .

   String s = "I";
   String s1 = s.concat("am").concat("good").concat("boy");
   System.out.println(s1);

   Dalam kasus di atas, Anda harus memberikan dua string wajib.

2. Perbedaan kedua dan utama antara + dan concat adalah:

   Kasus 1: Misalkan saya menggabungkan string yang sama dengan operator concat dengan cara ini

   String s="I";
   String s1=s.concat("am").concat("good").concat("boy");
   System.out.println(s1);

   Dalam hal ini jumlah objek yang dibuat dalam kumpulan adalah 7 seperti ini:

   I
   am
   good
   boy
   Iam
   Iamgood
   Iamgoodboy

   Kasus 2:

   Sekarang saya akan menggabungkan string yang sama melalui operator +

   String s="I"+"am"+"good"+"boy";
   System.out.println(s);

   Dalam kasus di atas, jumlah objek yang dibuat hanya 5.

   Sebenarnya ketika kita meringkas string melalui + operator maka ia mempertahankan kelas StringBuffer untuk melakukan tugas yang sama sebagai berikut: -

   StringBuffer sb = new StringBuffer("I");
   sb.append("am");
   sb.append("good");
   sb.append("boy");
   System.out.println(sb);

   Dengan cara ini hanya akan membuat lima objek.

Jadi ini adalah perbedaan mendasar antara + dan metode concat . Nikmati :)

Demi kelengkapan, saya ingin menambahkan bahwa definisi operator '+' dapat ditemukan di JLS SE8 15.18.1 :

Jika hanya satu ekspresi operan yang bertipe String, maka konversi string (§5.1.11) dilakukan pada operan lainnya untuk menghasilkan string pada saat run time.

Hasil penggabungan string adalah referensi ke objek String yang merupakan penggabungan dua string operan. Karakter operan kiri mendahului karakter operan kanan dalam string yang baru dibuat.

Objek String baru dibuat (§12.5) kecuali jika ekspresi adalah ekspresi konstan (§15.28).

Tentang implementasi JLS mengatakan hal berikut:

Implementasi dapat memilih untuk melakukan konversi dan penggabungan dalam satu langkah untuk menghindari membuat dan kemudian membuang objek String perantara. Untuk meningkatkan kinerja penggabungan string berulang, kompiler Java dapat menggunakan kelas StringBuffer atau teknik serupa untuk mengurangi jumlah objek String menengah yang dibuat dengan mengevaluasi ekspresi.

Untuk tipe primitif, implementasi juga dapat mengoptimalkan pembuatan objek wrapper dengan mengonversi langsung dari tipe primitif ke string.

Jadi menilai dari 'kompiler Java dapat menggunakan kelas StringBuffer atau teknik serupa untuk mengurangi', kompiler yang berbeda dapat menghasilkan byte-code yang berbeda.

The + Operator dapat bekerja antara string dan string, char, integer, double atau mengambang nilai tipe data. Itu hanya mengkonversi nilai ke representasi string sebelum penggabungan.

The Operator concat hanya dapat dilakukan dan dengan string. Ia memeriksa kompatibilitas tipe data dan membuat kesalahan, jika tidak cocok.

Kecuali ini, kode yang Anda berikan melakukan hal yang sama.

Saya kira tidak.

a.concat(b)diimplementasikan dalam String dan saya pikir implementasi tidak banyak berubah sejak mesin java awal. The +pelaksanaan operasi tergantung pada versi Jawa dan compiler. Saat +ini diimplementasikan menggunakanStringBuffer untuk membuat operasi secepat mungkin. Mungkin di masa depan, ini akan berubah. Dalam versi sebelumnya dari +operasi java pada Strings jauh lebih lambat karena menghasilkan hasil antara.

Saya kira itu +=diimplementasikan menggunakan +dan dioptimalkan serupa.

Saat menggunakan +, kecepatan berkurang seiring bertambahnya panjang string, tetapi saat menggunakan concat, kecepatannya lebih stabil, dan opsi terbaik adalah menggunakan kelas StringBuilder yang memiliki kecepatan stabil untuk melakukan itu.

Saya kira Anda bisa mengerti mengapa. Tetapi cara terbaik untuk membuat string panjang adalah menggunakan StringBuilder () dan append (), kecepatan keduanya tidak dapat diterima.