Kekekalan String di Jawa

Perhatikan contoh berikut.

String str = new String();

str  = "Hello";
System.out.println(str);  //Prints Hello

str = "Help!";
System.out.println(str);  //Prints Help!

Sekarang, di Jawa, objek String tidak dapat diubah. Lalu bagaimana bisa benda itustr tersebut diberi nilai "Bantuan!". Bukankah ini bertentangan dengan kekekalan string di Jawa? Adakah yang bisa menjelaskan konsep imutabilitas yang tepat?

Edit:

Baik. Saya sekarang mengerti, tetapi hanya satu pertanyaan lanjutan. Bagaimana dengan kode berikut:

String str = "Mississippi"; 
System.out.println(str); // prints Mississippi 

str = str.replace("i", "!"); 
System.out.println(str); // prints M!ss!ss!pp! 

Apakah ini berarti bahwa dua objek dibuat lagi ("Mississippi" dan "M! Ss! Ss! Pp!") Dan referensi strmenunjuk ke objek yang berbeda setelah replace()metode?

strbukan objek, ini referensi ke objek. "Hello"dan "Help!"dua Stringbenda berbeda . Dengan demikian, str menunjuk ke sebuah string. Anda dapat mengubah apa yang ditunjukkannya , tetapi bukan apa yang ditunjukkannya .

Ambil kode ini, misalnya:

String s1 = "Hello";
String s2 = s1;
// s1 and s2 now point at the same string - "Hello"

Sekarang, tidak ada ¹ yang bisa kami lakukan untuk s1yang akan mempengaruhi nilai s2. Mereka merujuk ke objek yang sama - string "Hello"- tetapi objek itu tidak berubah dan dengan demikian tidak dapat diubah.

Jika kita melakukan sesuatu seperti ini:

s1 = "Help!";
System.out.println(s2); // still prints "Hello"

Di sini kita melihat perbedaan antara bermutasi suatu objek, dan mengubah referensi. s2masih menunjuk ke objek yang sama seperti yang kita setel awalnya s1. Pengaturan s1untuk "Help!"hanya mengubah referensi , sedangkan Stringobjek yang awalnya dirujuk tetap tidak berubah.

Jika string dapat diubah, kita dapat melakukan sesuatu seperti ini:

String s1 = "Hello";
String s2 = s1;
s1.setCharAt(1, 'a'); // Fictional method that sets character at a given pos in string
System.out.println(s2); // Prints "Hallo"

Edit untuk menanggapi edit OP:

Jika Anda melihat kode sumber untuk String.replace (char, char) (juga tersedia di src.zip di direktori instalasi JDK Anda - tip pro adalah untuk melihat ke sana setiap kali Anda bertanya-tanya bagaimana sesuatu benar-benar berfungsi) Anda dapat melihat apa yang dilakukannya adalah sebagai berikut:

• Jika ada satu atau lebih kemunculan oldChardalam string saat ini, buat salinan dari string saat ini di mana semua kemunculan oldChardiganti newChar.
• Jika oldChartidak ada dalam string saat ini, kembalikan string saat ini.

Jadi ya, "Mississippi".replace('i', '!')buat Stringobjek baru . Sekali lagi, yang berikut ini berlaku:

String s1 = "Mississippi";
String s2 = s1;
s1 = s1.replace('i', '!');
System.out.println(s1); // Prints "M!ss!ss!pp!"
System.out.println(s2); // Prints "Mississippi"
System.out.println(s1 == s2); // Prints "false" as s1 and s2 are two different objects

Pekerjaan rumah Anda untuk saat ini adalah untuk melihat apa yang dilakukan kode di atas jika Anda berubah s1 = s1.replace('i', '!');menjadi s1 = s1.replace('Q', '!');:)

¹ Sebenarnya, itu adalah mungkin untuk string bermutasi (dan objek abadi lainnya). Ini membutuhkan refleksi dan sangat, sangat berbahaya dan tidak boleh digunakan kecuali Anda benar-benar tertarik menghancurkan program.

Objek yang strreferensi dapat berubah, tetapi Stringobjek yang sebenarnya tidak bisa.

The Stringbenda yang mengandung string "Hello"dan "Help!"tidak dapat mengubah nilai-nilai mereka, maka mereka berubah.

Kekekalan Stringobjek tidak berarti bahwa referensi yang menunjuk ke objek tidak dapat berubah.

Salah satu cara seseorang dapat mencegah perubahan strreferensi adalah dengan mendeklarasikannya sebagai final:

final String STR = "Hello";

Sekarang, mencoba untuk menetapkan lain Stringuntuk STRakan menyebabkan error kompilasi.

Light_handle Saya sarankan Anda membaca Ukuran Cup - sebuah cerita tentang variabel dan Pass-by-Value Please (Ukuran Cup lanjutan) . Ini akan banyak membantu ketika membaca posting di atas.

Sudahkah Anda membacanya? Iya. Baik.

String str = new String();

Ini menciptakan "remote control" baru yang disebut " str" dan menyetelnya ke nilai new String()(atau "").

misalnya dalam memori ini menciptakan:

str --- > ""

str  = "Hello";

Ini kemudian mengubah " str" remote control tetapi tidak mengubah string asli "".

misalnya dalam memori ini menciptakan:

str -+   ""
     +-> "Hello"

str = "Help!";

Ini kemudian mengubah " str" remote control tetapi tidak mengubah string asli"" atau objek yang saat ini menunjuk remote control.

misalnya dalam memori ini menciptakan:

str -+   ""
     |   "Hello"
     +-> "Help!"

Mari kita istirahat menjadi beberapa bagian

String s1 = "hello";

Pernyataan ini menciptakan string yang berisi halo dan menempati ruang dalam memori yaitu di Constant String Pool dan dan menetapkannya ke objek referensi s1

String s2 = s1;

Pernyataan ini memberikan string yang sama halo ke s2 referensi baru

         __________
        |          |
s1 ---->|  hello   |<----- s2
        |__________| 

Kedua referensi menunjuk ke string yang sama sehingga menghasilkan nilai yang sama seperti berikut.

out.println(s1);    // o/p: hello
out.println(s2);    // o/p: hello

Meskipun String tidak dapat diubah , penugasan dapat dimungkinkan sehingga s1 sekarang akan merujuk ke tumpukan nilai baru .

s1 = "stack";    
         __________
        |          |
s1 ---->|  stack   |
        |__________|

Tapi bagaimana dengan objek s2 yang menunjuk ke hello itu akan seperti apa adanya.

         __________
        |          |
s2 ---->|  hello   |
        |__________|

out.println(s1);    // o/p: stack
out.println(s2);    // o/p: hello

Karena String tidak dapat diubah Java Virtual Machine tidak akan mengizinkan kami untuk memodifikasi string s1 dengan metodenya. Ini akan membuat semua objek String baru di kumpulan sebagai berikut.

s1.concat(" overflow");

                 ___________________
                |                   |
s1.concat ----> |  stack overflow   |
                |___________________|

out.println(s1);    // o/p: stack
out.println(s2);    // o/p: hello
out.println(s1.concat); // o/p: stack overflow

Catatan jika String akan bisa berubah maka output akan menjadi

out.println(s1);    // o/p: stack overflow

Sekarang Anda mungkin terkejut mengapa String memiliki metode seperti concat () untuk dimodifikasi. Cuplikan berikut akan menghapus kebingungan Anda.

s1 = s1.concat(" overflow");

Di sini kita menetapkan nilai string yang dimodifikasi kembali ke referensi s1 .

         ___________________
        |                   |
s1 ---->|  stack overflow   |
        |___________________|


out.println(s1);    // o/p: stack overflow
out.println(s2);    // o/p: hello

Itu sebabnya Java memutuskan bahwa String adalah kelas final. Jika tidak, siapa pun dapat memodifikasi dan mengubah nilai string. Semoga ini bisa membantu sedikit.

Objek string yang pertama kali dirujuk oleh strtidak diubah, semua yang Anda lakukan adalah membuat strmerujuk ke objek string baru.

String tidak akan berubah, referensi untuk itu akan berubah. Anda membingungkan kekekalan dengan konsep finalbidang. Jika suatu bidang dinyatakan sebagai final, setelah ditetapkan, bidang itu tidak dapat dipindahkan.

Mengenai penggantian bagian dari pertanyaan Anda, coba ini:

String str = "Mississippi"; 
System.out.println(str); //Prints Mississippi 

String other = str.replace("i", "!"); 
System.out.println(str); //still prints Mississippi 
System.out.println(other);  // prints M!ss!ss!pp!

Meskipun java mencoba mengabaikannya, strtidak lebih dari sebuah pointer. Ini berarti bahwa ketika Anda pertama kali menulis str = "Hello";, Anda membuat objek yang strmenunjuk. Ketika Anda menetapkan ulang strdengan menulis str = "Help!";, objek baru dibuat dan "Hello"objek lama mendapat sampah yang dikumpulkan setiap kali java merasa seperti itu.

Kekekalan menyiratkan bahwa nilai objek yang dipakai tidak dapat berubah, Anda tidak pernah dapat mengubah "Halo" menjadi "Bantuan!".

Str variabel adalah referensi ke objek, ketika Anda menetapkan nilai baru untuk str Anda tidak mengubah nilai objek yang dirujuk, Anda mereferensikan objek yang berbeda.

Kelas string tidak dapat diubah, dan Anda tidak dapat mengubah nilai objek tidak berubah. Tetapi dalam kasus String, jika Anda mengubah nilai string daripada itu akan membuat string baru dalam kumpulan string dan dari referensi string Anda ke nilai itu bukan yang lebih lama. jadi dengan cara ini string tidak dapat diubah. Mari kita ambil contoh,

String str = "Mississippi";  
System.out.println(str); // prints Mississippi 

itu akan membuat satu string "Mississippi" dan akan menambahkannya ke kolam String jadi sekarang str menunjuk ke Mississippi.

str = str.replace("i", "!");  
System.out.println(str); // prints M!ss!ss!pp! 

Tetapi setelah operasi di atas, satu string lain akan dibuat "M! Ss! Ss! Pp!" dan itu akan ditambahkan ke kolam String. dan sekarang str menunjuk ke M! ss! ss! pp !, bukan Mississippi.

jadi dengan cara ini ketika Anda akan mengubah nilai objek string itu akan membuat satu objek lagi dan akan menambahkannya ke kumpulan string.

Mari kita punya satu contoh lagi

String s1 = "Hello"; 
String s2 = "World"; 
String s = s1 + s2;

tiga baris di atas ini akan menambahkan tiga objek string ke string pool.
1) Halo
2) Dunia
3) HelloWorld

Menggunakan:

String s = new String("New String");
s.concat(" Added String");
System.out.println("String reference -----> "+s); // Output: String reference -----> New String

Jika Anda lihat di sini saya menggunakan concatmetode untuk mengubah string asli, yaitu, "String Baru" dengan string "String Ditambahkan", tapi masih saya mendapatkan output seperti sebelumnya, maka itu membuktikan bahwa Anda tidak dapat mengubah referensi objek kelas String, tetapi jika Anda melakukan hal ini dengan kelas StringBuilder itu akan berhasil. Itu tercantum di bawah ini.

StringBuilder sb = new StringBuilder("New String");
sb.append(" Added String");
System.out.println("StringBuilder reference -----> "+sb);// Output: StringBuilder reference -----> New String Added String

Seperti yang dikatakan Linus Tolvards:

Berbicara itu murah. Tunjukkan kodenya

Lihatlah ini:

public class Test{
    public static void main(String[] args){

        String a = "Mississippi";
        String b = "Mississippi";//String immutable property (same chars sequence), then same object

        String c = a.replace('i','I').replace('I','i');//This method creates a new String, then new object
        String d = b.replace('i','I').replace('I','i');//At this moment we have 3 String objects, a/b, c and d

        String e = a.replace('i','i');//If the arguments are the same, the object is not affected, then returns same object

        System.out.println( "a==b? " + (a==b) ); // Prints true, they are pointing to the same String object

        System.out.println( "a: " + a );
        System.out.println( "b: " + b );

        System.out.println( "c==d? " + (c==d) ); // Prints false, a new object was created on each one

        System.out.println( "c: " + c ); // Even the sequence of chars are the same, the object is different
        System.out.println( "d: " + d );

        System.out.println( "a==e? " + (a==e) ); // Same object, immutable property
    }
}

Outputnya adalah

a==b? true
a: Mississippi
b: Mississippi
c==d? false
c: Mississippi
d: Mississippi
a==e? true

Jadi, ingat dua hal:

• String tidak dapat diubah hingga Anda menerapkan metode yang memanipulasi dan membuat yang baru (c & d case).
• Metode Replace mengembalikan objek String yang sama jika kedua parameternya sama

Bagi mereka yang bertanya-tanya bagaimana cara memecahkan String immutability di Java ...

Kode

import java.lang.reflect.Field;

public class StringImmutability {
    public static void main(String[] args) {
        String str1 = "I am immutable";
        String str2 = str1;

        try {
            Class str1Class = str1.getClass();
            Field str1Field = str1Class.getDeclaredField("value");

            str1Field.setAccessible(true);
            char[] valueChars = (char[]) str1Field.get(str1);

            valueChars[5] = ' ';
            valueChars[6] = ' ';

            System.out.println(str1 == str2);
            System.out.println(str1);
            System.out.println(str2);           
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }
}

Keluaran

true
I am   mutable
I am   mutable

String tidak berubah . Yang artinya kita hanya bisa mengubah referensi .

String a = "a";
System.out.println("String a is referencing to "+a); // Output: a

a.concat("b");
System.out.println("String a is referencing to "+a); // Output: a

a = a.concat("b");
System.out.println("String a has created a new reference and is now referencing to "+a); // Output: ab

Di Jawa, objek umumnya diakses oleh referensi. Dalam potongan kode Anda str adalah referensi yang pertama kali ditugaskan untuk "Halo" (objek yang dibuat secara otomatis atau diambil dari kumpulan konstan ) dan kemudian Anda menetapkan objek lain "Bantuan!" untuk referensi yang sama. Poin yang perlu diperhatikan adalah referensi sama dan dimodifikasi, tetapi objek berbeda. Satu hal lagi dalam kode Anda, Anda mengakses tiga objek,

1. Ketika Anda memanggil String baru ().
2. Saat Anda menetapkan "halo".
3. Ketika Anda menetapkan "tolong!".

Memanggil String baru () membuat objek baru bahkan jika itu ada di string pool, jadi umumnya tidak boleh digunakan. Untuk meletakkan string yang dibuat dari String baru () ke dalam kumpulan string, Anda dapat mencoba intern()metode ini.

Saya harap ini membantu.

Kekekalan yang bisa saya katakan adalah bahwa Anda tidak dapat mengubah String itu sendiri. Misalkan Anda memiliki String x, nilainya "abc". Sekarang Anda tidak dapat mengubah String, yaitu, Anda tidak dapat mengubah karakter apa pun di "abc".

Jika Anda harus mengubah karakter apa pun di String, Anda dapat menggunakan array karakter dan mengubahnya atau menggunakan StringBuilder.

String x = "abc";
x = "pot";
x = x + "hj";
x = x.substring(3);
System.out.println(x);

char x1[] = x.toCharArray();
x1[0] = 's';
String y = new String(x1);
System.out.println(y);

Keluaran:

hj
sj

Atau Anda dapat mencoba:

public class Tester
{
public static void main(String[] args)
{
 String str = "Mississippi"; 
 System.out.println(str); // prints Mississippi 
 System.out.println(str.hashCode());

 str = str.replace("i", "!"); 
 System.out.println(str); // prints M!ss!ss!pp! 
 System.out.println(str.hashCode());
 }
 }

Ini akan menunjukkan bagaimana kode hash berubah.

String tidak dapat diubah artinya Anda tidak dapat mengubah objek itu sendiri, tetapi Anda dapat mengubah referensi ke objek tersebut. Ketika Anda memanggil a = "ty", Anda sebenarnya mengubah referensi a ke objek baru yang dibuat oleh String literal "ty". Mengubah objek berarti menggunakan metode untuk mengubah salah satu bidangnya (atau bidang bersifat publik dan bukan final, sehingga dapat diperbarui dari luar tanpa mengaksesnya melalui metode), misalnya:

Foo x = new Foo("the field");
x.setField("a new field");
System.out.println(x.getField()); // prints "a new field"

Sementara di kelas yang tidak dapat diubah (dinyatakan sebagai final, untuk mencegah modifikasi melalui pewarisan) (metodenya tidak dapat memodifikasi bidangnya, dan juga bidang selalu pribadi dan direkomendasikan untuk final), misalnya String, Anda tidak dapat mengubah String saat ini tetapi Anda dapat mengembalikan String baru, yaitu:

String s = "some text";
s.substring(0,4);
System.out.println(s); // still printing "some text"
String a = s.substring(0,4);
System.out.println(a); // prints "some"

Di sini immutability berarti instance dapat menunjuk ke referensi lain tetapi konten asli dari string tidak akan diubah pada referensi asli. Biarkan saya jelaskan dengan contoh pertama yang Anda berikan. Str pertama menunjuk ke "Halo", ok untuk ini. Kedua kalinya menunjuk ke "Bantuan!". Di sini str mulai menunjuk ke "Tolong!" dan referensi dari string "Hello" hilang dan kami tidak bisa mendapatkannya kembali.

Bahkan ketika str akan mencoba untuk memodifikasi konten yang ada, maka string baru akan dihasilkan dan str akan mulai menunjuk pada referensi itu. Jadi kita melihat bahwa string pada referensi asli tidak dimodifikasi tetapi aman pada referensi dan contoh objek mulai menunjuk pada referensi yang berbeda sehingga ketidakmampuan dipertahankan.

Super terlambat menjawab, tetapi ingin memberikan pesan singkat dari penulis kelas String di Jawa

String adalah konstan; nilai-nilai mereka tidak dapat diubah setelah mereka dibuat. Buffer string mendukung string yang dapat berubah. Karena objek String tidak dapat diubah, mereka dapat dibagi.

Dapat diturunkan dari dokumentasi ini bahwa apa pun yang mengubah string, mengembalikan objek yang berbeda (yang bisa baru atau diinternir dan lama). Petunjuk tidak begitu halus tentang ini harus berasal dari tanda tangan fungsi. Pikirkan tentang hal ini, 'Mengapa mereka membuat fungsi pada suatu objek mengembalikan sebuah objek alih-alih status?'.

public String replace(char oldChar, char newChar) 

Juga satu lagi sumber yang membuat perilaku ini eksplisit (Dari ganti fungsi dokumentasi)

Mengembalikan string baru yang dihasilkan dari mengganti semua kemunculan oldChar di string ini dengan newChar.

Sumber: https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#replace(char,%20char)

• penulis Lee Boynton
• penulis Arthur van Hoff
• penulis Martin Buchholz
• penulis Ulf Zibis

Sumber: JavaDoc of String.

String Obyek - metode itu sendiri dibuat menjadi "tidak berubah". Tindakan ini tidak menghasilkan perubahan: "letters.replace (" bbb "," aaa ");"

Namun penetapan data menyebabkan perubahan pada konten Strings berubah:

    letters = "aaa";
    letters=null;
    System.out.println(letters);
    System.out.println(oB.hashCode());
    System.out.println(letters);
    letters = "bbbaaa";
    System.out.println(oB.hashCode());
    System.out.println(letters);

// Kode hash dari string Object tidak berubah.

Jika HELLOadalah Anda String maka Anda tidak dapat mengubah HELLOkeHILLO . Properti ini disebut properti kekekalan.

Anda dapat memiliki beberapa variabel String penunjuk ke titik String HELLO.

Tetapi jika HELLO adalah char Array maka Anda dapat mengubah HELLO menjadi HILLO. Misalnya,

char[] charArr = 'HELLO';
char[1] = 'I'; //you can do this

Bahasa pemrograman memiliki variabel data yang tidak berubah sehingga dapat digunakan sebagai kunci dalam pasangan nilai.

Saya akan menjelaskannya dengan contoh sederhana

pertimbangkan array karakter apa pun: mis. char a [] = {'h', 'e', ​​'l', 'l', 'o'}; dan sebuah string: String s = "hello";

pada array karakter kita dapat melakukan operasi seperti mencetak hanya tiga huruf terakhir menggunakan iterating array; tetapi dalam string kita harus membuat objek String baru dan menyalin substring yang diperlukan dan alamatnya akan berada di objek string baru.

misalnya

***String s="hello";
String s2=s.substrig(0,3);***

jadi s2 akan memiliki "hel";

String di Java dalam Immutable dan Final hanya berarti tidak dapat diubah atau dimodifikasi:

Kasus 1:

class TestClass{  
 public static void main(String args[]){  
   String str = "ABC";  
   str.concat("DEF");  
   System.out.println(str);  
 }  
} 

Output: ABC

Alasan: Str referensi objek tidak berubah pada kenyataannya objek baru "DEF" dibuat yang ada di pool dan tidak memiliki referensi sama sekali (yaitu hilang).

Kasus 2:

class TestClass{  
 public static void main(String args[]){  
   String str="ABC";  
   str=str.concat("DEF");  
   System.out.println(str);  
 }  
}  

Output: ABCDEF

Alasan: Dalam hal ini str sekarang merujuk ke objek baru "ABCDEF" maka ia mencetak ABCDEF yaitu objek str sebelumnya "ABC" hilang di kumpulan tanpa referensi.

Karena String tidak dapat diubah, maka perubahan tidak akan terjadi jika Anda tidak akan menetapkan nilai fungsi yang dikembalikan ke string.so di pertanyaan Anda, nilai swap fungsi nilai yang dikembalikan ke s.

s = swap (s, n1, n2); maka nilai string s akan berubah.

Saya juga mendapatkan nilai yang tidak berubah ketika saya menulis program untuk mendapatkan beberapa string permutasi (Meskipun tidak memberikan semua permutasi tetapi ini misalnya untuk menjawab pertanyaan Anda)

Berikut ini sebuah contoh.

> import java.io.*;  public class MyString { public static void
> main(String []args)throws IOException {  BufferedReader br=new
> BufferedReader(new InputStreamReader(System.in));  String
> s=br.readLine().trim(); int n=0;int k=0;  while(n!=s.length()) {
> while(k<n){  swap(s,k,n); System.out.println(s); swap(s,k,n); k++; }
> n++; } }  public static void swap(String s,int n1,int n2) { char temp;
> temp=s.charAt(n1); StringBuilder sb=new StringBuilder(s);
> sb.setCharAt(n1,s.charAt(n2)); sb.setCharAt(n2,temp); s=sb.toString();
> } }

tetapi saya tidak mendapatkan nilai-nilai permutasi string dari kode di atas. Jadi saya menetapkan nilai yang dikembalikan dari fungsi swap ke string dan mendapat nilai string yang diubah. setelah menetapkan nilai yang dikembalikan saya mendapat nilai string yang diijinkan.

/import java.util.*; import java.io.*; public class MyString { public static void main(String []args)throws IOException{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); 
String s=br.readLine().trim(); int n=0;int k=0; 
while(n!=s.length()){ while(k<n){ s=swap(s,k,n); 
System.out.println(s); s=swap(s,k,n); k++; } n++; } } 
public static String swap(String s,int n1,int n2){
char temp; temp=s.charAt(n1); StringBuilder sb=new StringBuilder(s); sb.setCharAt(n1,s.charAt(n2)); sb.setCharAt(n2,temp); s=sb.toString(); return s; } }

    public final class String_Test {

    String name;
    List<String> list=new ArrayList<String>();

    public static void main(String[] args) {

        String_Test obj=new String_Test();
        obj.list.add("item");//List will point to a memory unit- i.e will have one Hashcode value #1234

        List<String> list2=obj.list; //lis1 also will point to same #1234

        obj.list.add("new item");//Hashcode of list is not altered- List is mutable, so reference remains same, only value in that memory location changes

        String name2=obj.name="Myname"; // name2 and name will point to same instance of string -Hashcode #5678
        obj.name = "second name";// String is Immutable- New String HAI is created and name will point to this new instance- bcoz of this Hashcode changes here #0089

        System.out.println(obj.list.hashCode());
        System.out.println(list2.hashCode());
        System.out.println(list3.hashCode());

        System.out.println("===========");
        System.out.println(obj.name.hashCode());
        System.out.println(name2.hashCode());
    }
}

Akan menghasilkan mengeluarkan sesuatu seperti ini

1419358369 1419358369

103056 65078777

Tujuan dari objek yang tidak dapat diubah adalah nilainya tidak boleh diubah begitu ditugaskan. Ini akan mengembalikan objek baru setiap kali Anda mencoba mengubahnya berdasarkan implementasi. Catatan: Stringbuffer sebagai ganti string dapat digunakan untuk menghindari hal ini.

Untuk pertanyaan terakhir Anda :: u akan memiliki satu referensi, dan 2 string dalam kumpulan string .. Kecuali referensi akan menunjuk ke m! Ss! Ss! Pp!