Apakah string Java benar-benar tidak berubah?

Kita semua tahu bahwa Stringitu tidak dapat diubah di Jawa, tetapi periksa kode berikut:

String s1 = "Hello World";  
String s2 = "Hello World";  
String s3 = s1.substring(6);  
System.out.println(s1); // Hello World  
System.out.println(s2); // Hello World  
System.out.println(s3); // World  

Field field = String.class.getDeclaredField("value");  
field.setAccessible(true);  
char[] value = (char[])field.get(s1);  
value[6] = 'J';  
value[7] = 'a';  
value[8] = 'v';  
value[9] = 'a';  
value[10] = '!';  

System.out.println(s1); // Hello Java!  
System.out.println(s2); // Hello Java!  
System.out.println(s3); // World  

Mengapa program ini beroperasi seperti ini? Dan mengapa nilai s1dans2 berubah, tetapi tidak s3?

String tidak dapat diubah * tetapi ini hanya berarti Anda tidak dapat mengubahnya menggunakan API publiknya.

Apa yang Anda lakukan di sini adalah menghindari API normal, menggunakan refleksi. Dengan cara yang sama, Anda dapat mengubah nilai enum, mengubah tabel pencarian yang digunakan dalam bilangan bulat Integer dll.

Sekarang, alasan s1dan s2nilai perubahan, adalah bahwa keduanya merujuk ke string yang diinternir yang sama. Kompiler melakukan ini (sebagaimana disebutkan oleh jawaban lain).

Alasannya s3sebenarnya tidak sedikit mengejutkan bagi saya, karena saya pikir itu akan berbagi valuearray ( itu dalam versi Java yang lebih lama , sebelum Java 7u6). Namun, melihat kode sumber String, kita dapat melihat bahwa valuearray karakter untuk substring sebenarnya disalin (menggunakan Arrays.copyOfRange(..)). Inilah mengapa itu tidak berubah.

Anda dapat menginstal SecurityManager, untuk menghindari kode berbahaya untuk melakukan hal-hal seperti itu. Tetapi perlu diingat bahwa beberapa perpustakaan bergantung pada penggunaan trik-trik refleksi semacam ini (biasanya alat ORM, perpustakaan AOP dll).

*) Saya awalnya menulis bahwa Strings tidak benar-benar abadi, hanya "tidak dapat diubah". Ini mungkin menyesatkan dalam implementasi saat ini String, di mana valuearray memang ditandai private final. Namun, masih perlu dicatat bahwa tidak ada cara untuk mendeklarasikan array di Java sebagai tidak dapat diubah, jadi harus berhati-hati untuk tidak mengeksposnya di luar kelasnya, bahkan dengan pengubah akses yang tepat.

Karena topik ini tampaknya sangat populer, inilah beberapa saran untuk bacaan lebih lanjut: Refleksi Madness Heinz Kabutz dari JavaZone 2009, yang mencakup banyak masalah di OP, bersama dengan refleksi lain ... well ... kegilaan.

Ini mencakup mengapa ini kadang berguna. Dan mengapa, sebagian besar waktu, Anda harus menghindarinya. :-)

Di Jawa, jika dua variabel primitif string diinisialisasi ke literal yang sama, itu menetapkan referensi yang sama untuk kedua variabel:

String Test1="Hello World";
String Test2="Hello World";
System.out.println(test1==test2); // true

Itulah alasan perbandingan kembali benar. String ketiga dibuat dengan menggunakan substring()yang membuat string baru alih-alih menunjuk ke yang sama.

Saat Anda mengakses string menggunakan refleksi, Anda mendapatkan pointer aktual:

Field field = String.class.getDeclaredField("value");
field.setAccessible(true);

Jadi perubahan ini akan mengubah string yang memegang pointer ke sana, tetapi karena s3dibuat dengan string baru karena substring()itu tidak akan berubah.

Anda menggunakan refleksi untuk menghindari kekekalan String - ini adalah bentuk "serangan".

Ada banyak contoh yang dapat Anda buat seperti ini (misalnya Anda bahkan dapat membuat Voidinstance objek juga), tetapi itu tidak berarti bahwa String tidak "tidak dapat diubah".

Ada kasus penggunaan di mana jenis kode ini dapat digunakan untuk keuntungan Anda dan menjadi "pengkodean yang baik", seperti membersihkan kata sandi dari memori pada saat yang paling dini (sebelum GC) .

Tergantung pada manajer keamanan, Anda mungkin tidak dapat mengeksekusi kode Anda.

Anda menggunakan refleksi untuk mengakses "detail implementasi" objek string. Kekekalan adalah fitur antarmuka publik dari suatu objek.

Pengubah visibilitas dan final (yaitu ketidakmampuan) bukan merupakan ukuran terhadap kode berbahaya di Jawa; mereka hanyalah alat untuk melindungi dari kesalahan dan untuk membuat kode lebih dapat dipertahankan (salah satu nilai jual besar dari sistem). Itulah sebabnya Anda dapat mengakses detail implementasi internal seperti array char dukungan untuk Stringmelalui refleksi.

Efek kedua yang Anda lihat adalah bahwa semua Stringberubah sementara sepertinya Anda hanya berubah s1. Ini adalah properti tertentu dari Java String literal yang secara otomatis diinternir, yaitu di-cache. Dua String literal dengan nilai yang sama sebenarnya akan menjadi objek yang sama. Ketika Anda membuat sebuah String dengan newitu tidak akan diinternir secara otomatis dan Anda tidak akan melihat efek ini.

#substringhingga baru-baru ini (Java 7u6) bekerja dengan cara yang serupa, yang akan menjelaskan perilaku dalam versi asli pertanyaan Anda. Itu tidak membuat array char backing baru tetapi menggunakan kembali dari String asli; itu hanya menciptakan objek String baru yang menggunakan offset dan panjang untuk menyajikan hanya sebagian dari array itu. Ini umumnya berfungsi sebagai String tidak dapat diubah - kecuali Anda menghindarinya. Properti ini dari#substring juga berarti bahwa seluruh String asli tidak dapat berupa sampah yang dikumpulkan ketika substring yang lebih pendek dibuat darinya masih ada.

Pada Java saat ini dan versi pertanyaan Anda saat ini tidak ada perilaku aneh #substring.

String immutability berasal dari perspektif antarmuka. Anda menggunakan refleksi untuk memintas antarmuka dan secara langsung memodifikasi internal instance String.

s1dan s2keduanya diubah karena keduanya ditugaskan ke instance String "intern" yang sama. Anda dapat menemukan sedikit lebih banyak tentang bagian itu dari artikel ini tentang kesetaraan string dan magang. Anda mungkin terkejut mengetahui bahwa dalam kode sampel Anda,s1 == s2 kembali true!

Versi Java mana yang Anda gunakan? Dari Java 1.7.0_06, Oracle telah mengubah representasi internal String, terutama substring.

Mengutip dari Oracle Tunes Internal String Representation Java :

Dalam paradigma baru, bidang offset dan hitung String telah dihapus, sehingga substring tidak lagi berbagi nilai karakter yang mendasarinya.

Dengan perubahan ini, itu bisa terjadi tanpa refleksi (???).

Sebenarnya ada dua pertanyaan di sini:

1. Apakah string benar-benar tidak berubah?
2. Mengapa s3 tidak diubah?

Ke poin 1: Kecuali untuk ROM tidak ada memori yang tidak dapat diubah di komputer Anda. Saat ini bahkan ROM terkadang dapat ditulis. Selalu ada beberapa kode di suatu tempat (apakah itu kernel atau kode asli yang menghindari lingkungan terkelola Anda) yang dapat menulis ke alamat memori Anda. Jadi, dalam "kenyataan", tidak, mereka tidak mutlak abadi.

Ke poin 2: Ini karena substring mungkin mengalokasikan contoh string baru, yang kemungkinan menyalin array. Dimungkinkan untuk menerapkan substring sedemikian rupa sehingga tidak akan melakukan salinan, tetapi itu tidak berarti demikian. Ada pengorbanan yang terlibat.

Sebagai contoh, haruskah memegang referensi yang reallyLargeString.substring(reallyLargeString.length - 2)menyebabkan sejumlah besar memori tetap hidup, atau hanya beberapa byte?

Itu tergantung pada bagaimana substring diimplementasikan. Salinan yang dalam akan menjaga lebih sedikit memori yang hidup, tetapi akan berjalan sedikit lebih lambat. Salinan dangkal akan membuat lebih banyak memori hidup, tetapi akan lebih cepat. Menggunakan salinan yang dalam juga dapat mengurangi fragmentasi tumpukan, karena objek string dan buffernya dapat dialokasikan dalam satu blok, sebagai lawan dari 2 alokasi tumpukan terpisah.

Bagaimanapun, sepertinya JVM Anda memilih untuk menggunakan salinan yang dalam untuk panggilan substring.

Untuk menambah jawaban @ haraldK - ini adalah peretasan keamanan yang dapat menyebabkan dampak serius pada aplikasi.

Hal pertama adalah modifikasi string konstan yang disimpan dalam String Pool. Ketika string dideklarasikan sebagai a String s = "Hello World";, string ditempatkan ke dalam kumpulan objek khusus untuk digunakan kembali secara potensial. Masalahnya adalah bahwa kompiler akan menempatkan referensi ke versi yang dimodifikasi pada waktu kompilasi dan setelah pengguna memodifikasi string yang disimpan dalam kumpulan ini saat runtime, semua referensi dalam kode akan menunjuk ke versi yang dimodifikasi. Ini akan menghasilkan bug berikut:

System.out.println("Hello World"); 

Akan dicetak:

Hello Java!

Ada masalah lain yang saya alami ketika saya menerapkan perhitungan berat atas string berisiko tersebut. Ada bug yang terjadi pada 1 dari 10.000 kali selama perhitungan yang membuat hasilnya tidak dapat ditentukan. Saya dapat menemukan masalah dengan mematikan JIT - Saya selalu mendapatkan hasil yang sama dengan JIT dimatikan. Dugaan saya adalah bahwa alasannya adalah peretasan keamanan String ini yang mematahkan beberapa kontrak optimasi JIT.

Menurut konsep pooling, semua variabel String yang berisi nilai yang sama akan mengarah ke alamat memori yang sama. Oleh karena itu s1 dan s2, keduanya mengandung nilai yang sama "Hello World", akan mengarah ke lokasi memori yang sama (katakanlah M1).

Di sisi lain, s3 berisi "Dunia", maka itu akan menunjuk ke alokasi memori yang berbeda (katakanlah M2).

Jadi sekarang yang terjadi adalah bahwa nilai S1 sedang diubah (dengan menggunakan nilai char []). Jadi nilai di lokasi memori M1 yang ditunjukkan oleh s1 dan s2 telah berubah.

Oleh karena itu, lokasi memori M1 telah dimodifikasi yang menyebabkan perubahan nilai s1 dan s2.

Tetapi nilai lokasi M2 tetap tidak berubah, karenanya s3 berisi nilai asli yang sama.

Alasan s3 tidak benar-benar berubah adalah karena di Jawa ketika Anda melakukan substring, array karakter nilai untuk substring disalin secara internal (menggunakan Arrays.copyOfRange ()).

s1 dan s2 adalah sama karena di Jawa keduanya merujuk ke string yang diinternir yang sama. Ini dengan desain di Jawa.

String tidak dapat diubah, tetapi melalui refleksi Anda diizinkan untuk mengubah kelas String. Anda baru saja mendefinisikan ulang kelas String sebagai bisa berubah secara real-time. Anda dapat mendefinisikan kembali metode menjadi publik atau pribadi atau statis jika Anda inginkan.

[Penafian ini adalah gaya jawaban yang sengaja dikemukakan pendapat karena saya merasa lebih "jangan lakukan ini di rumah anak-anak" jawaban diperlukan]

Dosa adalah garis field.setAccessible(true); yang mengatakan melanggar api publik dengan mengizinkan akses ke bidang pribadi. Itulah lubang keamanan raksasa yang dapat dikunci dengan mengkonfigurasi manajer keamanan.

Fenomena dalam pertanyaan ini adalah detail implementasi yang tidak akan pernah Anda lihat ketika tidak menggunakan baris kode berbahaya tersebut untuk melanggar pengubah akses melalui refleksi. Jelas dua (biasanya) string yang tidak dapat diubah dapat berbagi array char yang sama. Apakah substring berbagi array yang sama tergantung pada apakah substring dapat dan apakah pengembang berpikir untuk membagikannya. Biasanya ini adalah detail implementasi yang tidak terlihat yang seharusnya tidak perlu Anda ketahui kecuali Anda memotret pengubah akses melalui kepala dengan baris kode tersebut.

Ini bukan ide yang baik untuk mengandalkan detail yang tidak bisa dialami tanpa melanggar pengubah akses menggunakan refleksi. Pemilik kelas itu hanya mendukung API publik normal dan bebas untuk membuat perubahan implementasi di masa mendatang.

Setelah mengatakan semua itu, baris kode benar-benar sangat berguna ketika Anda memegang pistol di kepala Anda dan memaksa Anda untuk melakukan hal-hal berbahaya seperti itu. Menggunakan pintu belakang itu biasanya merupakan bau kode yang perlu Anda tingkatkan ke kode perpustakaan yang lebih baik di mana Anda tidak perlu berbuat dosa. Penggunaan umum lain dari baris kode berbahaya itu adalah untuk menulis "kerangka kerja voodoo" (orm, container injeksi, ...). Banyak orang menjadi religius tentang kerangka kerja seperti itu (baik untuk dan melawan mereka) jadi saya akan menghindari mengundang perang api dengan mengatakan tidak lain dari sebagian besar programmer tidak harus pergi ke sana.

String dibuat di area permanen memori tumpukan JVM. Jadi ya, itu benar-benar abadi dan tidak dapat diubah setelah dibuat. Karena dalam JVM, ada tiga jenis memori tumpukan: 1. Generasi muda 2. Generasi tua 3. Generasi permanen.

Ketika objek apa pun dibuat, ia masuk ke area tumpukan generasi muda dan area PermGen dicadangkan untuk pengumpulan string.

Berikut ini detail lebih lanjut yang bisa Anda tuju dan dapatkan lebih banyak informasi dari: Bagaimana Pengumpulan Sampah bekerja di Jawa .

String bersifat abadi karena tidak ada metode untuk memodifikasi objek String. Itulah alasan mereka diperkenalkan StringBuilder dan StringBuffer kelas