java - 为什么说String的拼接会产生很多的无用对象呢？

Question

为什么说String的拼接会产生很多的无用对象呢？
eg.
String str = "";
while(true){

str +="abc";

}

按我的理解，字符串拼接只会在常量池中创建共享对象，常量池的对象会被垃圾回收器回收吗？为什么说会产生很多无用的对象，需要垃圾回收，从而影响程序性能呢？

Answer 1

Berkenaan dengan apa yang dikatakan oleh poster itu, penyambungan rentetan hanya akan mencipta objek kongsi dalam kolam malar, saya tidak faham maksudnya secara khusus, tetapi saya boleh menjelaskan mengapa cara penulisan ini menghasilkan banyak objek yang tidak berguna akan membantu Poster asal sangat membantu.

Inilah jawapannya:

Lihat gambar di atas terlebih dahulu Kelas String dalam JDK ialah kelas akhir, dan nilai yang digunakan untuk menyimpan aksara String juga adalah muktamad!

Ini bermakna bahawa nilai objek rentetan tidak boleh diubah suai selepas ia dicipta! Oleh itu, rentetan yang dijana oleh setiap gelung mestilah objek Rentetan baharu. Tetapi kod di atas menjana lebih banyak objek daripada yang anda fikirkan! silaTeruskan melihat gambar!

----------------------Barisan pemisah yang indah--------------------- - -------

Kotak merah dalam gambar kedua ialah kod yang dinyahkompilasi dalam kotak merah dalam gambar pertama. Ia boleh dilihat daripada gambar:
a+=a;

1. Panggil String.valueOf(a). Dalam langkah ini, kerana a juga merupakan rentetan, tiada objek baharu akan dijana.

2. StringBulid baharu (objek pertama sebenarnya rentetan a), langkah ini akan menjana objek Stringbuild.

3. .tambah(rentetan ditambah)

4. .toString(), langkah ini akan memanggil kaedah toString Stringbuild.

Mari kita lihat kod sumber toString() Stringbuild

public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }

Aduh! Mengapa objek String lain dicipta?

Penghuraian a+=a selesai di sini, jadi setiap operasi penambahan rentetan dalam gelung sebenarnya mencipta sekurang-kurangnya satu objek StringBuild dan satu objek String!

Answer 2

String ialah objek tidak boleh ubah, jadi setiap kali jenis String ditukar, ia sebenarnya bersamaan dengan menghasilkan objek String baharu, dan kemudian menghalakan penuding ke objek String baharu, jadi rentetan yang kerap menukar kandungan adalah yang paling Ia adalah lebih baik untuk tidak menggunakan String, kerana setiap kali objek dijana, ia akan memberi kesan kepada prestasi sistem Terutama apabila terdapat terlalu banyak objek yang tidak dirujuk dalam memori, GC JVM akan mula berfungsi, dan kelajuannya pasti akan menjadi. agak perlahan.

Untuk pembolehubah yang kerap diubah suai, StringBuffer harus digunakan~

Answer 3

... Hanya selepas jdk1.8 StringBuild boleh digunakan untuk berbilang penyambungan rentetan. . Versi lama tidak seperti ini! ~~
Saya membaca artikel 0 0 kali terakhir dan saya tidak tahu sama ada ia salah.
Sebelum 1.8, pelbagai pengubahsuaian String memerlukan penggunaan StringBuffer atau StringBuilder.
1.8 telah mendayakan gula sintaksis dan mengubah suai kawasan ini, membolehkan kami menikmati kecekapan tinggi tanpa memanggil StringBuilder secara eksplisit.

Dan untuk rentetan, anda hanya akan mencipta objek kongsi dalam kolam malar,

str +="abc";
1.abc
2.abcabc
3........

Bukankah setiap objek yang dicipta di sini adalah objek yang tidak berguna? Selain keputusan akhir, kitar semula GC juga mengambil masa.

Oleh kerana rentetan ialah pengubahsuaian akhir char[], objek baharu mesti dibuat setiap kali
Sebab mengapa StringBuilder begitu cekap ialah tatasusunan dikembangkan secara dinamik, biasanya dengan menambah operasi , hanya mencipta a char [] baru yang lebih besar apabila kapasiti penuh, dan salin data lama sebelum menambahnya, secara ringkasnya, stringbuilder mengurangkan penjanaan objek dan tidak perlu menjana objek baharu setiap kali. Sila minta bimbingan pakar! ~! ~! ~