Saya mencoba untuk memahami apa praktik terbaik dan mengapa menggabungkan string literal dan variabel untuk kasus yang berbeda. Misalnya jika saya memiliki kode seperti ini
StringBuilder sb = new StringBuilder("AAAAAAAAAAAAA")
.append(B_String).append("CCCCCCCCCCC").append(D_String)
.append("EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE")
.append("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
Apakah ini cara melakukannya? Dari posting ini , saya perhatikan bahwa +
operator di Strings membuat instance baru dari StringBuilder, menggabungkan operan, dan mengembalikan konversi String, yang sepertinya lebih banyak bekerja daripada hanya memanggil .append()
; jadi jika itu benar, maka itu tidak mungkin. Tapi bagaimana dengan String.concat()
? Apakah tepat digunakan .append()
untuk setiap penggabungan? Atau hanya untuk variabel, dan literal boleh ditambahkan .concat()
?
StringBuilder sb = new StringBuilder("AAAAAAAAAAAAA")
.append(B_String.concat("CCCCCCCCCCC")).append(D_String
.concat("EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE")
.concat("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"));
Apa aturan umum untuk praktik dan kinerja terbaik untuk menghadapi situasi ini? Apakah asumsi saya benar +
dan seharusnya tidak digunakan?
sumber
Jawaban:
+
operatorDi balik layar ini diterjemahkan ke:
String s = new StringBuilder(s1).append(s2).toString();
Bayangkan berapa banyak pekerjaan ekstra yang ditambahkannya jika Anda ada di
s1 + s2
sini:dari pada:
Beberapa string dengan
+
Perlu dicatat bahwa:
diterjemahkan ke:
String s = new StringBuilder(s1).append(s2).append(s3)...apend(sN).toString();
concat()
String
membuatchar[]
larik yang bisa memuats1
dans2
. Salinans1
dans2
konten ke array baru ini. Sebenarnya membutuhkan lebih sedikit pekerjaan daripada+
operator.StringBuilder.append()
Mempertahankan
char[]
larik internal yang tumbuh saat dibutuhkan. Tidak ada tambahanchar[]
yang dibuat jika internal cukup besar.juga berkinerja buruk karena
s1.concat(s2)
membuatchar[]
larik tambahan dan menyalins1
dans2
hanya untuk menyalin konten larik baru itu ke internalStringBuilder
char[]
.Karena itu, Anda harus menggunakan
append()
sepanjang waktu dan menambahkan string mentah (cuplikan kode pertama Anda benar).sumber
+
objek String daripada membuatStringBuilder
untuk penggabungan satu kali ini, karena pada dasarnya akan melakukan hal yang sama?Penyusun mengoptimalkan + penggabungan.
Begitu
int a = 1; String s = "Hello " + a;
diubah menjadi
new StringBuilder().append("Hello ").append(1).toString();
Ada topik bagus di sini yang menjelaskan mengapa Anda harus menggunakan operator +.
sumber
String s = "Hello World";
karena Anda menggunakan literal.Optimasi dilakukan secara otomatis oleh compiler.
Kompilator Java2 secara otomatis akan mengubah yang berikut ini:
untuk
String s = (new StringBuffer()).append(s1).append(s2).toString();
Diambil langsung dari Praktik Terbaik Java di situs web Oracles.
sumber
Anda harus selalu menggunakan
append
.concat
buat String baru jadi seperti yang+
saya pikirkan.Jika Anda
concat
atau menggunakan+
dengan 2 string terakhir, JVM dapat melakukan optimasi sehingga sama seperti melakukan append dalam kasus ini.sumber
Jika Anda menggabungkan dua String dengan tepat, gunakan String.concat (buat String baru dengan membuat array-karakter baru yang cocok dengan String dan menyalin kedua array karakter Strings ke dalamnya).
Jika Anda menggabungkan beberapa (lebih dari dua) String dalam satu baris, gunakan + atau StringBuilder.append, tidak masalah, karena kompilator mengubah + menjadi StringBuilder.append. Ini bagus untuk beberapa String karena mempertahankan satu array karakter yang tumbuh sesuai kebutuhan.
Jika Anda menggabungkan beberapa String ke beberapa baris, buat satu StringBuilder dan gunakan metode append. Pada akhirnya ketika Anda selesai menambahkan Strings ke StringBuilder gunakan metode .toString () - untuk membuat String darinya. Untuk menggabungkan dalam beberapa baris, ini lebih cepat daripada metode kedua, karena metode kedua akan membuat StringBuilder baru di setiap baris, menambahkan Strings dan kemudian melemparkan kembali ke String, sedangkan metode ketiga hanya menggunakan satu StringBuilder untuk semuanya.
sumber
Gunakan
+
operator adalah praktik terbaik, juga sederhana dan mudah dibaca.Dokumen resmi: https://docs.oracle.com/javase/8/docs/api/java/lang/String.html
sumber
dalam tingkat kode byte tidak ada perbedaan dan kami tidak mengorbankan efisiensi di sana. Dalam kasus mengeksekusi level kode byte, itu harus melalui metode overloading operator non-inline untuk + dengan memanggil append. kemudian pada level bahasa assembly (Java ditulis dalam C dan C menghasilkan assemblies yang mirip dengan assembly, akan ada tambahan register call untuk menyimpan + pemanggilan metode di stack dan akan ada tambahan push. (pada kenyataannya, cross-compiler dapat mengoptimalkan + operator panggilan, dalam hal ini membuatnya tidak berbeda dengan efisiensi.)
Merupakan praktik yang baik untuk memiliki satu cara untuk meningkatkan keterbacaan. :)
sumber
Saya pribadi lebih suka pemformat string
Strings.format()
satu baris yang mudah dibaca dan sederhana .String b = "B value"; String d = "D value"; String fullString = String.format("A %s C %s E F", b, d); // Output: A B value C D value E F
sumber
Semua jawaban cukup bagus dan jelas. Tapi saya merasa eksplorasi seputar teknik penggabungan string lainnya juga akan membantu seperti - Guava Joiner, Streams, String.format, dll.
Untuk detail lengkap tentang performa setiap teknik penggabungan java-string-concatenation-which-way-is-best .
Singkatnya, kinerja penggabungan bervariasi dengan no. string untuk digabungkan. Misalnya - untuk menggabungkan 1-10 string, teknik ini bekerja paling baik - StringBuilder, StringBuffer dan Plus Operator. Dan untuk menggabungkan 100 string - Guava Joiner, pustaka stringsUtils apache juga berfungsi dengan baik.
Silakan buka blog di atas. Ini benar-benar menjelaskan efisiensi kinerja dengan sangat baik.
Terima kasih.
sumber