Perbedaan Mutabilitas:
String
adalah kekal , jika Anda mencoba untuk mengubah nilai-nilai mereka, objek lain akan dibuat, sedangkan StringBuffer
dan StringBuilder
yang bisa berubah sehingga mereka dapat mengubah nilai-nilai mereka.
Perbedaan Thread-Safety:
Perbedaan antara StringBuffer
dan StringBuilder
apakah itu StringBuffer
aman-thread. Jadi ketika aplikasi perlu dijalankan hanya dalam satu utas maka lebih baik digunakan StringBuilder
. StringBuilder
lebih efisien daripada StringBuffer
.
Situasi:
- Jika string Anda tidak akan berubah, gunakan kelas String karena
String
objek tidak dapat diubah.
- Jika string Anda dapat berubah (misalnya: banyak logika dan operasi dalam pembuatan string) dan hanya akan diakses dari satu utas, penggunaan a
StringBuilder
cukup baik.
- Jika string Anda dapat berubah, dan akan diakses dari banyak utas, gunakan
StringBuffer
karena StringBuffer
sinkron sehingga Anda memiliki keamanan utas.
Strings
ketika kita mengubah nilai objek lain dibuat. Apakah referensi objek lama dibatalkan sehingga mungkin sampah yang dikumpulkan olehGC
atau bahkan sampah yang dikumpulkan?String
denganStringBuilder
?String
saat struktur yang tidak dapat diubah sesuai; memperoleh urutan karakter baru dari aString
dapat membawa penalti kinerja yang tidak dapat diterima, baik dalam waktu CPU atau memori (memperoleh substring adalah CPU yang efisien karena data tidak disalin, tetapi ini berarti jumlah data yang berpotensi jauh lebih besar mungkin tetap dialokasikan).StringBuilder
saat Anda perlu membuat urutan karakter yang bisa berubah, biasanya untuk menyatukan beberapa urutan karakter secara bersamaan.StringBuffer
dalam keadaan yang sama Anda akan gunakanStringBuilder
, tetapi ketika perubahan pada string yang mendasarinya harus disinkronkan (karena beberapa utas membaca / memodifikasi dalam buffer string).Lihat contoh di sini .
sumber
Dasar:
String
adalah kelas yang tidak dapat diubah, tidak dapat diubah.StringBuilder
adalah kelas yang bisa berubah yang dapat ditambahkan ke, karakter diganti atau dihapus dan akhirnya dikonversi keString
StringBuffer
adalah versi asli disinkronkanStringBuilder
Anda harus memilih
StringBuilder
dalam semua kasus di mana Anda hanya memiliki satu utas mengakses objek Anda.Rinciannya:
Juga perhatikan bahwa
StringBuilder/Buffers
itu bukan sihir, mereka hanya menggunakan Array sebagai objek pendukung dan bahwa Array harus dialokasikan kembali ketika sudah penuh. Pastikan dan buatStringBuilder/Buffer
objek Anda cukup besar di tempat asalnya tidak harus selalu diukur ulang setiap kali.append()
dipanggil.Pengubahan ukuran bisa sangat memburuk. Ini pada dasarnya kembali ukuran Array dukungan untuk 2 kali ukuran saat ini setiap kali perlu diperluas. Ini dapat menyebabkan sejumlah besar RAM mendapatkan alokasi dan tidak digunakan ketika
StringBuilder/Buffer
kelas mulai tumbuh besar.Di Jawa
String x = "A" + "B";
menggunakan diStringBuilder
belakang layar. Jadi untuk kasus-kasus sederhana tidak ada manfaatnya menyatakan milik Anda sendiri. Tetapi jika Anda membangunString
objek yang besar, katakanlah kurang dari 4k, maka menyatakanStringBuilder sb = StringBuilder(4096);
jauh lebih efisien daripada penggabungan atau menggunakan konstruktor default yang hanya 16 karakter. Jika AndaString
akan kurang dari 10k maka inisialisasi dengan konstruktor ke 10k agar aman. Tetapi jika diinisialisasi ke 10k maka Anda menulis 1 karakter lebih dari 10k, itu akan dialokasikan kembali dan disalin ke array 20k. Jadi menginisialisasi tinggi lebih baik daripada rendah.Dalam kasus ukuran ulang otomatis, pada karakter ke-17, Array dukungan akan dialokasikan kembali dan disalin ke 32 karakter, pada karakter ke-33 ini terjadi lagi dan Anda bisa mengalokasikan kembali dan menyalin Array ke dalam 64 karakter. Anda dapat melihat bagaimana ini merosot ke banyak alokasi ulang dan salinan yang merupakan apa yang Anda benar-benar coba hindari menggunakan
StringBuilder/Buffer
di tempat pertama.Ini dari kode sumber JDK 6 untuk AbstractStringBuilder
Praktik terbaik adalah menginisialisasi yang
StringBuilder/Buffer
sedikit lebih besar dari yang Anda pikir akan Anda butuhkan jika Anda tidak tahu berapa besarString
akan tetapi Anda bisa menebaknya. Satu alokasi memori yang sedikit lebih banyak daripada yang Anda butuhkan akan lebih baik daripada banyak alokasi ulang dan salinan.Juga berhati-hatilah dalam menginisialisasi a
StringBuilder/Buffer
denganString
yang hanya akan mengalokasikan ukuran karakter String + 16, yang dalam kebanyakan kasus hanya akan memulai alokasi ulang yang merosot dan menyalin siklus yang Anda coba hindari. Berikut ini adalah langsung dari kode sumber Java 6.Jika Anda kebetulan berakhir dengan contoh
StringBuilder/Buffer
yang tidak Anda buat dan tidak dapat mengontrol konstruktor yang dipanggil, ada cara untuk menghindari perilaku alokasi ulang dan salin yang merosot. Panggil.ensureCapacity()
dengan ukuran yang Anda inginkan untuk memastikan hasil AndaString
sesuai.Alternatif:
Sama seperti catatan, jika Anda melakukan pembangunan dan manipulasi yang sangat berat
String
, ada alternatif yang lebih berorientasi pada kinerja yang disebut Tali .Alternatif lain, adalah membuat
StringList
implementasi dengan subklasifikasiArrayList<String>
, dan menambahkan penghitung untuk melacak jumlah karakter pada setiap.append()
dan operasi mutasi lainnya dari daftar, kemudian mengganti.toString()
untuk membuatStringBuilder
ukuran persis yang Anda butuhkan dan mengulang-ulang daftar dan membangun output, Anda bahkan dapat membuatStringBuilder
variabel instan dan 'cache' hasil.toString()
dan hanya perlu menghasilkan kembali ketika sesuatu berubah.Juga jangan lupa
String.format()
ketika membangun output terformat tetap, yang dapat dioptimalkan oleh kompiler karena mereka membuatnya lebih baik.sumber
String x = "A" + "B";
benar-benar mengkompilasi menjadi StringBuilder? Mengapa tidak dikompilasi sajaString x = "AB";
, seharusnya hanya menggunakan StringBuilder jika komponen tidak diketahui pada waktu kompilasi.Apakah maksud Anda, untuk penggabungan?
Contoh dunia nyata: Anda ingin membuat string baru dari banyak lainnya .
Misalnya untuk mengirim pesan:
Tali
StringBuilder
Atau
StringBuffer (sintaksnya persis seperti dengan StringBuilder, efeknya berbeda)
Tentang
StringBuffer
vs.StringBuilder
Yang pertama disinkronkan dan kemudian tidak.
Jadi, jika Anda menjalankannya beberapa kali dalam satu utas (yang merupakan 90% dari semua casing),
StringBuilder
akan berjalan jauh lebih cepat karena tidak akan berhenti untuk melihat apakah ia memiliki kunci utas.Jadi, disarankan untuk menggunakan
StringBuilder
(kecuali tentu saja Anda memiliki lebih dari satu utas mengaksesnya pada saat yang sama, yang jarang terjadi)String
Rangkaian ( menggunakan operator + ) dapat dioptimalkan oleh kompiler untuk digunakan diStringBuilder
bawahnya, jadi, itu bukan lagi sesuatu yang perlu dikhawatirkan, di masa tua Jawa, ini adalah sesuatu yang semua orang katakan harus dihindari dengan cara apa pun, karena setiap rangkaian membuat objek String baru. Kompiler modern tidak melakukan ini lagi, tetapi tetap merupakan praktik yang baik untuk digunakanStringBuilder
sebagai gantinya jika Anda menggunakan kompiler "lama".sunting
Hanya untuk yang penasaran, inilah yang dilakukan oleh kompiler untuk kelas ini:
javap -c StringConcatenation
Baris bernomor 5 - 27 adalah untuk String yang bernama "literal"
Baris bernomor 31-53 untuk String bernama "builder"
Tidak ada perbedaan, kode yang sama persis dijalankan untuk kedua string.
sumber
StringBuilder
gabungan string to do di sisi kanan penugasan. Setiap implementasi yang baik akan menggunakan StringBuilder di belakang layar seperti yang Anda katakan. Selanjutnya, contoh Anda"a" + "b"
akan dikompilasi menjadi satu literal"ab"
tetapi jika Anda menggunakannyaStringBuilder
akan menghasilkan dua panggilan yang tidak perluappend()
."a"+"b"
tetapi untuk mengatakan apa yang merupakan rangkaian String tentang saya mengubahnya menjadi eksplisit. Apa yang tidak Anda katakan adalah, mengapa bukan praktik yang baik untuk melakukannya. Itulah yang dilakukan oleh kompiler (modern). @ fuzzy, saya setuju, khususnya ketika Anda tahu ukuran string terakhir (aprox).sumber
synchronised
dan itulah sebabnya .Tali
The
String class
mewakili karakter string. Semua string literal dalam program Java, seperti"abc"
diimplementasikan sebagai instance dari kelas ini.Objek string tidak dapat diubah setelah dibuat, kita tidak dapat mengubah. ( String adalah konstanta )
Jika sebuah String dibuat menggunakan konstruktor atau metode maka string tersebut akan disimpan dalam Heap Memory juga
SringConstantPool
. Tetapi sebelum menyimpan di kolam itu memanggilintern()
metode untuk memeriksa ketersediaan objek dengan konten yang sama di kolam menggunakan metode sama. Jika String-copy tersedia di Pool maka mengembalikan referensi. Jika tidak, objek String ditambahkan ke kumpulan dan mengembalikan referensi.+
), dan untuk konversi objek lain ke string. Rangkaian string diimplementasikan melalui kelas StringBuilder (atau StringBuffer) dan metode appendnya.String literal disimpan di
StringConstantPool
.StringBuilder dan StringBuffer adalah urutan karakter yang bisa berubah. Itu berarti seseorang dapat mengubah nilai objek ini. StringBuffer memiliki metode yang sama dengan StringBuilder, tetapi setiap metode di StringBuffer disinkronkan sehingga aman untuk thread.
Data StringBuffer dan StringBuilder hanya dapat dibuat menggunakan operator baru. Jadi, mereka disimpan dalam memori Heap.
Contoh dari StringBuilder tidak aman untuk digunakan oleh banyak utas. Jika sinkronisasi seperti itu diperlukan maka disarankan agar StringBuffer digunakan.
StringBuffer dan StringBuilder memiliki metode khusus seperti.,
replace(int start, int end, String str)
Danreverse()
.Kapan harus menggunakan yang mana.
Jika a Anda tidak akan mengubah nilai setiap kali maka lebih baik Digunakan
String Class
. Sebagai bagian dari Generik jika Anda ingin MenyortirComparable<T>
atau membandingkan nilai, lalu gunakanString Class
.Jika Anda akan mengubah nilai setiap kali pergi untuk StringBuilder yang lebih cepat dari StringBuffer. Jika beberapa utas mengubah nilai, gunakan StringBuffer.
sumber
Juga,
StringBuffer
aman-thread, yangStringBuilder
tidak.Jadi dalam situasi waktu nyata ketika utas yang berbeda mengaksesnya,
StringBuilder
dapat memiliki hasil yang tidak ditentukan.sumber
Catatan bahwa jika Anda menggunakan Java 5 atau yang lebih baru, Anda harus menggunakan
StringBuilder
bukanStringBuffer
. Dari dokumentasi API:Dalam praktiknya, Anda hampir tidak akan pernah menggunakan ini dari banyak utas secara bersamaan, sehingga sinkronisasi yang
StringBuffer
dilakukannya hampir selalu tidak perlu di atas kepala.sumber
Secara pribadi, saya tidak berpikir ada gunanya menggunakan dunia nyata
StringBuffer
. Kapan saya ingin berkomunikasi antara banyak utas dengan memanipulasi urutan karakter? Kedengarannya tidak berguna sama sekali, tapi mungkin saya belum melihat cahaya :)sumber
Perbedaan antara String dan dua kelas lainnya adalah bahwa String tidak dapat diubah dan dua lainnya adalah kelas yang bisa berubah.
Tetapi mengapa kita memiliki dua kelas untuk tujuan yang sama?
Alasannya adalah
StringBuffer
Thread aman danStringBuilder
tidak.StringBuilder
adalah kelas baruStringBuffer Api
dan diperkenalkanJDK5
dan selalu disarankan jika Anda bekerja di lingkungan berulir tunggal seperti yang banyakFaster
Untuk Perincian Lengkap, Anda dapat membaca http://www.codingeek.com/java/stringbuilder-and-stringbuffer-a-way-to-create-mutable-strings-in-java/
sumber
Di java, String tidak dapat diubah. Menjadi kekal kita maksudkan bahwa sekali String dibuat, kita tidak bisa mengubah nilainya. StringBuffer bisa berubah. Setelah objek StringBuffer dibuat, kami hanya menambahkan konten ke nilai objek alih-alih membuat objek baru. StringBuilder mirip dengan StringBuffer tetapi tidak aman untuk thread. Metode StingBuilder tidak disinkronkan tetapi dibandingkan dengan String lainnya, Stringbuilder berjalan tercepat. Anda dapat mempelajari perbedaan antara String, StringBuilder dan StringBuffer dengan mengimplementasikannya.
sumber