Mengapa string tidak dapat diubah dalam Java dan .NET?

Mengapa mereka memutuskan untuk membuat Stringkekal di Java dan .NET (dan beberapa bahasa lainnya)? Mengapa mereka tidak membuatnya bisa berubah?

Menurut Java Efektif , bab 4, halaman 73, edisi ke-2:

"Ada banyak alasan bagus untuk ini: Kelas yang tidak berubah lebih mudah untuk merancang, mengimplementasikan, dan menggunakan daripada kelas yang bisa berubah. Mereka kurang rentan terhadap kesalahan dan lebih aman.

[...]

" Objek yang tidak dapat diubah adalah sederhana. Sebuah objek yang tidak dapat diubah dapat berada dalam satu keadaan, keadaan di mana ia dibuat. Jika Anda memastikan bahwa semua konstruktor membuat invarian kelas, maka dijamin bahwa invarian ini akan tetap benar untuk selamanya, dengan tidak ada usaha di pihak Anda.

[...]

Objek yang tidak dapat diubah secara inheren aman dari benang; mereka tidak memerlukan sinkronisasi. Mereka tidak dapat rusak oleh beberapa utas mengaksesnya secara bersamaan. Ini adalah pendekatan yang paling mudah untuk mencapai keselamatan benang. Bahkan, tidak ada utas yang dapat mengamati efek utas lain pada objek yang tidak dapat diubah. Oleh karena itu, objek yang tidak berubah dapat dibagikan secara bebas

[...]

Poin kecil lainnya dari bab yang sama:

Anda tidak hanya dapat berbagi objek yang tidak dapat diubah, tetapi Anda juga dapat membagikan bagian dalamnya.

[...]

Benda-benda yang tidak dapat berubah membuat blok bangunan yang bagus untuk benda-benda lain, apakah bisa berubah atau tidak berubah.

[...]

Satu-satunya kelemahan nyata dari kelas yang tidak dapat diubah adalah bahwa mereka membutuhkan objek yang terpisah untuk setiap nilai yang berbeda.

Setidaknya ada dua alasan.

Pertama - http://www.javafaq.nu/java-article1060.html keamanan

Alasan utama mengapa String membuat tidak dapat diubah adalah keamanan. Lihat contoh ini: Kami memiliki metode buka file dengan cek masuk. Kami meneruskan String ke metode ini untuk memproses otentikasi yang diperlukan sebelum panggilan akan diteruskan ke OS. Jika String bisa diubah, mungkin saja entah bagaimana memodifikasi kontennya setelah pemeriksaan otentikasi sebelum OS mendapatkan permintaan dari program, maka dimungkinkan untuk meminta file apa pun. Jadi, jika Anda memiliki hak untuk membuka file teks dalam direktori pengguna tetapi kemudian dengan cepat ketika entah bagaimana Anda berhasil mengubah nama file Anda dapat meminta untuk membuka file "passwd" atau yang lainnya. Kemudian file dapat dimodifikasi dan dimungkinkan untuk login langsung ke OS.

Kedua - Efisiensi memori http://hikrish.blogspot.com/2006/07/why-string-class-is-immutable.html

JVM secara internal memelihara "String Pool". Untuk mencapai efisiensi memori, JVM akan merujuk objek String dari kumpulan. Itu tidak akan membuat objek String baru. Jadi, setiap kali Anda membuat string literal baru, JVM akan memeriksa dalam kumpulan apakah sudah ada atau belum. Jika sudah ada di pool, cukup berikan referensi ke objek yang sama atau buat objek baru di pool. Akan ada banyak referensi menunjuk ke objek String yang sama, jika seseorang mengubah nilainya, itu akan mempengaruhi semua referensi. Jadi, matahari memutuskan untuk membuatnya tidak berubah.

Sebenarnya, alasan string tidak dapat diubah di java tidak ada hubungannya dengan keamanan. Dua alasan utama adalah sebagai berikut:

Keamanan Thead:

String adalah tipe objek yang sangat banyak digunakan. Oleh karena itu lebih atau kurang dijamin untuk digunakan dalam lingkungan multi-threaded. String tidak dapat diubah untuk memastikan bahwa string aman untuk dibagikan di antara utas. Memiliki string yang tidak dapat diubah memastikan bahwa ketika meneruskan string dari thread A ke thread B lainnya, thread B tidak dapat secara tak terduga memodifikasi string thread A.

Ini tidak hanya membantu menyederhanakan tugas pemrograman multi-utas yang sudah cukup rumit, tetapi juga membantu dengan kinerja aplikasi multi-utas. Akses ke objek yang dapat diubah harus entah bagaimana disinkronkan ketika mereka dapat diakses dari beberapa utas, untuk memastikan bahwa satu utas tidak berusaha membaca nilai objek Anda saat sedang dimodifikasi oleh utas lainnya. Sinkronisasi yang tepat keduanya sulit dilakukan dengan benar untuk programmer, dan mahal saat runtime. Objek yang tidak dapat diubah tidak dapat dimodifikasi dan oleh karena itu tidak perlu sinkronisasi.

Kinerja:

Sementara String magang telah disebutkan, itu hanya merupakan keuntungan kecil dalam efisiensi memori untuk program Java. Hanya string literal yang diinternir. Ini berarti bahwa hanya string yang sama dalam kode sumber Anda akan berbagi Objek String yang sama. Jika program Anda secara dinamis membuat string yang sama, mereka akan direpresentasikan dalam objek yang berbeda.

Lebih penting lagi, string yang tidak berubah memungkinkan mereka untuk berbagi data internal mereka. Untuk banyak operasi string, ini berarti bahwa array karakter yang mendasarinya tidak perlu disalin. Misalnya, Anda ingin mengambil lima karakter pertama dari String. Di Jawa, Anda akan memanggil myString.substring (0,5). Dalam hal ini, apa yang dilakukan oleh metode substring () adalah hanya membuat objek String baru yang membagikan karakter dasar myString [] tetapi siapa tahu bahwa itu dimulai pada indeks 0 dan berakhir pada indeks 5 dari char itu []. Untuk meletakkan ini dalam bentuk grafis, Anda akan berakhir dengan yang berikut:

 |               myString                  |
 v                                         v
"The quick brown fox jumps over the lazy dog"   <-- shared char[]
 ^   ^
 |   |  myString.substring(0,5)

Ini membuat jenis operasi ini sangat murah, dan O (1) karena operasi tidak tergantung pada panjang string asli, atau pada panjang substring yang perlu kita ekstrak. Perilaku ini juga memiliki beberapa manfaat memori, karena banyak string dapat berbagi karakter yang mendasarinya [].

Keselamatan dan kinerja benang. Jika sebuah string tidak dapat dimodifikasi, maka aman dan cepat untuk menyerahkan referensi di antara banyak utas. Jika string dapat diubah, Anda harus selalu menyalin semua byte dari string ke instance baru, atau memberikan sinkronisasi. Aplikasi tipikal akan membaca string 100 kali untuk setiap kali string perlu dimodifikasi. Lihat wikipedia tentang kekekalan .

Orang harus benar-benar bertanya, "mengapa X harus bisa berubah?" Lebih baik default ke kekekalan, karena manfaat yang telah disebutkan oleh Princess Fluff . Seharusnya pengecualian bahwa sesuatu bisa berubah.

Sayangnya sebagian besar bahasa pemrograman saat ini standar untuk mutabilitas, tetapi mudah-mudahan di masa depan standarnya lebih pada ketidakmampuan (lihat Daftar Keinginan untuk Bahasa Pemrograman Mainstream Berikutnya ).

Wow! Saya tidak percaya informasi yang salah di sini. StringMenjadi abadi tidak memiliki apa-apa dengan keamanan. Jika seseorang sudah memiliki akses ke objek dalam aplikasi yang sedang berjalan (yang harus diasumsikan jika Anda mencoba untuk menjaga terhadap seseorang 'peretasan' Stringdi aplikasi Anda), mereka tentu akan menjadi banyak peluang lain yang tersedia untuk peretasan.

Ini adalah ide yang cukup baru bahwa ketidakmampuan Stringmengatasi masalah threading. Hmmm ... Saya memiliki objek yang sedang diubah oleh dua utas berbeda. Bagaimana saya mengatasi ini? menyinkronkan akses ke objek? Naawww ... jangan biarkan siapa pun mengubah objek sama sekali - itu akan memperbaiki semua masalah konkurensi berantakan kami! Bahkan, mari kita membuat semua objek tidak berubah, dan kemudian kita dapat menghapus konstruksi yang disinkronkan dari bahasa Java.

Alasan sebenarnya (ditunjukkan oleh orang lain di atas) adalah optimasi memori. Sangat umum dalam aplikasi apa pun untuk string string yang sama digunakan berulang kali. Adalah sangat umum, pada kenyataannya, bahwa beberapa dekade yang lalu, banyak penyusun membuat optimasi menyimpan hanya satu contoh tunggal dari Stringliteral. Kelemahan dari optimasi ini adalah bahwa kode runtime yang memodifikasi Stringliteral menimbulkan masalah karena memodifikasi contoh untuk semua kode lain yang membagikannya. Sebagai contoh, akan tidak baik untuk suatu tempat fungsi dalam aplikasi untuk mengubah Stringliteral "dog"untuk "cat". A printf("dog")akan menghasilkan "cat"ditulis ke stdout. Untuk alasan itu, perlu ada cara untuk menjaga terhadap kode yang berusaha berubahStringliteral (yaitu, membuatnya tidak berubah). Beberapa kompiler (dengan dukungan dari OS) akan mencapai ini dengan menempatkan Stringliteral ke dalam segmen memori hanya baca khusus yang akan menyebabkan kesalahan memori jika upaya penulisan dilakukan.

Di Jawa ini dikenal sebagai magang. Kompiler Java di sini hanya mengikuti optimasi memori standar yang dilakukan oleh kompiler selama beberapa dekade. Dan untuk mengatasi masalah yang sama dari Stringliteral - literal ini yang sedang dimodifikasi saat runtime, Java hanya membuat Stringkelasnya tidak dapat diubah (mis. E, tidak memberi Anda setter yang memungkinkan Anda mengubah Stringkonten). StringTidak harus abadi jika pemusnahan Stringliteral tidak terjadi.

String bukan tipe primitif, namun Anda biasanya ingin menggunakannya dengan semantik nilai, yaitu seperti nilai.

Nilai adalah sesuatu yang bisa Anda percayai tidak akan berubah di belakang Anda. Jika Anda menulis: String str = someExpr(); Anda tidak ingin itu berubah kecuali ANDA melakukan sesuatu dengannya str.

Stringsebagai Objectmemiliki pointer semantik alami, untuk mendapatkan nilai semantik juga perlu berubah.

Salah satu faktornya adalah, jika String s dapat berubah, benda yang menyimpan Strings harus berhati-hati untuk menyimpan salinan, jangan sampai perubahan data internal mereka tanpa pemberitahuan. Mengingat bahwa Strings adalah tipe seperti angka yang cukup primitif, alangkah baiknya bila seseorang dapat memperlakukannya seolah-olah nilai-nilai itu dilewatkan, bahkan jika dilewatkan dengan referensi (yang juga membantu menghemat memori).

Aku tahu ini benjolan, tapi ... Apakah mereka benar-benar abadi? Pertimbangkan yang berikut ini.

public static unsafe void MutableReplaceIndex(string s, char c, int i)
{
    fixed (char* ptr = s)
    {
        *((char*)(ptr + i)) = c;
    }
}

...

string s = "abc";
MutableReplaceIndex(s, '1', 0);
MutableReplaceIndex(s, '2', 1);
MutableReplaceIndex(s, '3', 2);
Console.WriteLine(s); // Prints 1 2 3

Anda bahkan bisa menjadikannya metode ekstensi.

public static class Extensions
{
    public static unsafe void MutableReplaceIndex(this string s, char c, int i)
    {
        fixed (char* ptr = s)
        {
            *((char*)(ptr + i)) = c;
        }
    }
}

Yang membuat pekerjaan berikut ini

s.MutableReplaceIndex('1', 0);
s.MutableReplaceIndex('2', 1);
s.MutableReplaceIndex('3', 2);

Kesimpulan: Mereka dalam kondisi tidak berubah yang dikenal oleh kompiler. Tentu saja di atas hanya berlaku untuk string .NET karena Java tidak memiliki pointer. Namun string dapat sepenuhnya dapat diubah menggunakan pointer di C #. Ini bukan bagaimana pointer dimaksudkan untuk digunakan, memiliki penggunaan praktis atau digunakan dengan aman; Namun itu mungkin, sehingga menekuk seluruh aturan "bisa berubah". Anda biasanya tidak dapat mengubah indeks langsung dari string dan ini adalah satu-satunya cara. Ada cara yang bisa dicegah dengan melarang instance pointer dari string atau membuat salinan ketika string diarahkan, tetapi tidak dilakukan, yang membuat string dalam C # tidak sepenuhnya tidak dapat berubah.

Untuk sebagian besar tujuan, "string" adalah (digunakan / diperlakukan sebagai / dianggap / dianggap) unit atom yang bermakna , seperti halnya angka .

Bertanya mengapa karakter individu dari string tidak bisa berubah adalah seperti menanyakan mengapa bit individu dari integer tidak bisa berubah.

Anda harus tahu alasannya. Pikirkan saja itu.

Saya benci mengatakannya, tapi sayangnya kami memperdebatkan ini karena bahasa kami payah, dan kami mencoba menggunakan satu kata, string , untuk menggambarkan konsep atau kelas objek yang kompleks dan terletak secara kontekstual.

Kami melakukan perhitungan dan perbandingan dengan "string" yang mirip dengan yang kami lakukan dengan angka. Jika string (atau bilangan bulat) bisa berubah, kita harus menulis kode khusus untuk mengunci nilai-nilai mereka ke dalam formulir lokal yang tidak dapat diubah untuk melakukan segala jenis perhitungan dengan andal. Oleh karena itu, yang terbaik adalah memikirkan string seperti pengenal angka, tetapi alih-alih panjangnya 16, 32, atau 64 bit, panjangnya bisa ratusan bit.

Ketika seseorang mengatakan "string", kita semua memikirkan hal-hal yang berbeda. Mereka yang menganggapnya hanya sebagai seperangkat karakter, tanpa tujuan tertentu, tentu akan terkejut bahwa seseorang hanya memutuskan bahwa mereka seharusnya tidak dapat memanipulasi karakter tersebut. Tetapi kelas "string" bukan hanya array karakter. Ini STRING, bukan char[]. Ada beberapa asumsi dasar tentang konsep yang kita sebut sebagai "string", dan secara umum dapat digambarkan sebagai unit atom yang bermakna dari data kode seperti angka. Ketika orang berbicara tentang "memanipulasi string", mungkin mereka benar-benar berbicara tentang memanipulasi karakter untuk membangun string , dan StringBuilder sangat bagus untuk itu.

Pertimbangkan sejenak bagaimana rasanya jika string bisa berubah. Fungsi API berikut ini dapat diperdaya untuk mengembalikan informasi untuk pengguna yang berbeda jika string nama pengguna yang dapat diubah secara sengaja atau tidak sengaja diubah oleh utas lain ketika fungsi ini menggunakannya:

string GetPersonalInfo( string username, string password )
{
    string stored_password = DBQuery.GetPasswordFor( username );
    if (password == stored_password)
    {
        //another thread modifies the mutable 'username' string
        return DBQuery.GetPersonalInfoFor( username );
    }
}

Keamanan bukan hanya tentang 'kontrol akses', tetapi juga tentang 'keamanan' dan 'menjamin kebenaran'. Jika suatu metode tidak dapat dengan mudah ditulis dan diandalkan untuk melakukan perhitungan atau perbandingan sederhana dengan andal, maka tidak aman untuk menyebutnya, tetapi akan aman untuk mempertanyakan bahasa pemrograman itu sendiri.

Kekekalan tidak terkait erat dengan keamanan. Untuk itu, setidaknya di .NET, Anda mendapatkan SecureStringkelas.

Sunting nanti: Di ​​Jawa Anda akan menemukan GuardedString , implementasi yang serupa.

Keputusan untuk memiliki string yang bisa berubah dalam C ++ menyebabkan banyak masalah, lihat artikel yang sangat bagus ini oleh Kelvin Henney tentang Penyakit SAPI Gila .

SAPI = Salin Saat Menulis.

Ini adalah trade off. Strings pergi ke Stringkolam dan ketika Anda membuat beberapa identikString mereka berbagi memori yang sama. Para perancang memperkirakan teknik penghematan memori ini akan bekerja dengan baik untuk kasus umum, karena program-program cenderung untuk mengerjakan banyak hal yang sama.

Kelemahannya adalah bahwa rangkaian membuat banyak tambahan Stringyang hanya transisi dan hanya menjadi sampah, benar-benar merusak kinerja memori. Anda memiliki StringBufferdan StringBuilder(dalam Java, StringBuilderjuga dalam. NET) untuk digunakan untuk menyimpan memori dalam kasus ini.

Strings di Java tidak benar-benar berubah, Anda dapat mengubah nilainya menggunakan refleksi dan atau pemuatan kelas. Anda tidak boleh bergantung pada properti itu untuk keamanan. Sebagai contoh, lihat: Trik Sulap Di Jawa

Kekekalan baik. Lihat Java Efektif. Jika Anda harus menyalin sebuah String setiap kali Anda menyebarkannya, maka itu akan menjadi banyak kode rawan kesalahan. Anda juga bingung tentang modifikasi mana yang memengaruhi referensi mana. Dengan cara yang sama seperti Integer harus tetap untuk berperilaku seperti int, Strings harus berperilaku tidak berubah untuk bertindak seperti primitif. Dalam C ++ melewatkan string dengan nilai melakukan ini tanpa menyebutkan secara eksplisit dalam kode sumber.

Ada pengecualian untuk hampir setiap aturan:

using System;
using System.Runtime.InteropServices;

namespace Guess
{
    class Program
    {
        static void Main(string[] args)
        {
            const string str = "ABC";

            Console.WriteLine(str);
            Console.WriteLine(str.GetHashCode());

            var handle = GCHandle.Alloc(str, GCHandleType.Pinned);

            try
            {
                Marshal.WriteInt16(handle.AddrOfPinnedObject(), 4, 'Z');

                Console.WriteLine(str);
                Console.WriteLine(str.GetHashCode());
            }
            finally
            {
                handle.Free();
            }
        }
    }
}

Ini sebagian besar karena alasan keamanan. Jauh lebih sulit untuk mengamankan sistem jika Anda tidak dapat mempercayai bahwa Anda Stringrusak.