Незмінність рядків на Java

Розглянемо наступний приклад.

String str = new String();

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

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

Тепер у Java об'єкти String незмінні. Тоді як об’єкт strможе присвоїти значення "Допомога!". Хіба це не суперечить незмінності струн на Java? Може хто-небудь, будь ласка, пояснить мені точну концепцію непорушності?

Редагувати:

Гаразд. Зараз я отримую це, але лише одне наступне питання. Як щодо наступного коду:

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

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

Чи означає це, що два об’єкти створюються заново ("Міссісіпі" та "M! Ss! Ss! Pp!") Та опорними strточками на інший об'єкт після replace()методу?

strне є об'єктом, це посилання на об'єкт. "Hello"і "Help!"є двома різними Stringоб'єктами. Таким чином, str вказує на рядок. Ви можете змінити те, на що вказує , але не те, на що вказує .

Візьміть цей код, наприклад:

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

Тепер немає нічого ¹ ми могли б зробити , щоб , s1що б вплинути на вартість s2. Вони посилаються на той самий об'єкт - рядок "Hello"-, але цей об'єкт є незмінним і тому не може бути змінений.

Якщо ми робимо щось подібне:

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

Тут ми бачимо різницю між мутуванням об'єкта та зміною посилання. s2все ще вказує на той самий об’єкт, на який ми спочатку встановили s1. Установка s1для "Help!"змінює тільки посилання , в той час як Stringоб'єкт він спочатку означали залишається незмінною.

Якби рядки були змінними, ми могли б зробити щось подібне:

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"

Відредагуйте, щоб відповісти на зміни ОП:

Якщо ви подивитеся на вихідний код String.replace (char, char) (також доступний у src.zip у вашому каталозі установки JDK - підказка шукати там, коли вам цікаво, як щось насправді працює), ви можете побачити, що він робить наступне:

• Якщо oldCharв поточному рядку є одне або декілька входжень , зробіть копію поточного рядка, у якому всі входження oldCharзамінено на newChar.
• Якщо значення oldCharнемає в поточному рядку, поверніть поточний рядок.

Так що так, "Mississippi".replace('i', '!')створюється новий Stringоб’єкт. Знову справедливо наступне:

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

На сьогоднішній день ваше домашнє завдання полягає в тому, щоб побачити, що робити вищевказаний код, якщо ви перейдете s1 = s1.replace('i', '!');на s1 = s1.replace('Q', '!');:)

¹ На насправді, це можна мутувати рядки (і інші незмінні об'єкти). Він вимагає роздумів і є дуже, дуже небезпечним і ніколи не повинен використовуватися, якщо ви насправді не зацікавлені в знищенні програми.

Об'єкт, на який strпосилаються, може змінюватися, але самі фактичні Stringоб'єкти не можуть.

StringОб'єкти , що містить рядок "Hello"і "Help!"не може змінити їх, отже , вони незмінні.

Незмінність Stringоб'єктів не означає, що посилання, що вказують на об'єкт, не можуть змінюватися.

Один із способів запобігти strзміні посилання - це оголосити її як final:

final String STR = "Hello";

Тепер, намагаючись призначити інший , Stringщоб STRвикличе помилку компіляції.

Light_handle Я рекомендую прочитати розмір чашки - розповідь про змінні та " Pass-by-Value" (розмір чашки продовжується) . Це дуже допоможе при читанні публікацій вище.

Ви їх читали? Так. Добре.

String str = new String();

Це створює новий "пульт", який називається " str" і встановлює це значення new String()(або "").

наприклад, в пам'яті це створює:

str --- > ""

str  = "Hello";

Потім це змінює пульт дистанційного керування, strале " " не змінює початковий рядок "".

наприклад, в пам'яті це створює:

str -+   ""
     +-> "Hello"

str = "Help!";

Потім це змінює пульт дистанційного керування " str", але не змінює початкову рядок ""або об'єкт, на який в даний час вказує пульт.

наприклад, в пам'яті це створює:

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

Давайте розділимо його на деякі частини

String s1 = "hello";

Ця заява створює рядок, що містить привіт, і займає простір в пам'яті, тобто в пулі постійних струн, і призначає його посилальному об'єкту s1

String s2 = s1;

Це твердження призначає те саме рядкове привіт новому посиланню s2

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

Обидві посилання вказують на один і той же рядок, тому виведіть однакове значення, як описано нижче.

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

Хоча String є незмінним , призначення може бути можливим, тому s1 тепер буде посилатися на новий стек значень .

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

А як щодо s2 об’єкта, який вказує на привіт, він буде таким, як є.

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

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

Оскільки String є незмінним, віртуальна машина Java не дозволяє нам змінювати рядок s1 своїм методом. Це створить увесь новий об'єкт String в пулі наступним чином.

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

Зверніть увагу, якби String був би змінним, тоді був би вихід

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

Тепер ви можете здивуватися, чому для String є такі методи, як concat () для зміни. Наступний фрагмент очистить вашу плутанину.

s1 = s1.concat(" overflow");

Тут ми призначаємо змінене значення рядка назад до s1 посилання.

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


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

Ось чому Java вирішила, що String - це заключний клас, інакше кожен може змінити та змінити значення рядка. Сподіваюсь, це допоможе трохи.

Об'єкт рядка, на який вперше посилався, strне був змінений, все, що ви робили, - це strстосуватися нового об'єкта рядка.

Рядок не зміниться, посилання на нього буде. Ви плутаєте незмінність з поняттям finalполів. Якщо поле оголошено як final, щойно воно було призначене, воно не може бути перепризначене.

Щодо заміщення частини запитання, спробуйте це:

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!

Хоча Java намагається ігнорувати це, strце не що інше, як вказівник. Це означає, що коли ви вперше пишете str = "Hello";, ви створюєте об’єкт, на який strвказує. Коли ви перепризначаєте str, пишете str = "Help!";, створюється новий об’єкт, і старий "Hello"об’єкт збирає сміття, коли ява відчуває себе таким.

Незмінюваність означає, що значення об'єкта, що створюється, не може змінитися, ви ніколи не можете перетворити "Привіт" на "Довідка!".

Змінна str - це посилання на об'єкт, коли ви присвоюєте нове значення str, ви не змінюєте значення об'єкта, на який посилається, ви посилаєтесь на інший об'єкт.

Клас рядків незмінний, і ви не можете змінити значення незмінного об'єкта. Але у випадку String, якщо ви зміните значення рядка, воно створить нову рядок у пулі рядків і ніж ваша посилання рядка на це значення, а не на старе. тому таким чином рядок є незмінним. Давайте візьмемо ваш приклад,

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

він створить один рядок "Mississippi" і додасть його до String пулу, тому тепер str вказує на Mississippi.

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

Але після вищеописаної операції буде створено ще один рядок "M! Ss! Ss! Pp!" і він буде доданий до пулу String. і тепер str вказує на M! ss! ss! pp !, а не на Міссісіпі.

таким чином, коли ви зміните значення рядкового об'єкта, він створить ще один об'єкт і додасть його до пулу рядків.

Давайте ще один приклад

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

цей вище три рядки додасть три об’єкти рядка до пулу рядків.
1) Привіт
2) Світ
3) HelloWorld

Використання:

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

Якщо ви бачите тут, я використовую concatметод змінити початковий рядок, тобто "New String" з рядком "Добавлена ​​рядок", але все ж я отримав вихід як попередній, отже це доводить, що ви не можете змінити посилання на об'єкт класу String, але якщо ви зробите це за класом StringBuilder, воно буде працювати. Це перелічено нижче.

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

Як сказав Лінус Толвардс:

Розмова дешева. Покажіть мені код

Погляньте на це:

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
    }
}

Вихід є

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

Отже, запам'ятайте дві речі:

• Рядки незмінні до тих пір, поки ви не застосуєте метод, який маніпулює та створює новий (c & d випадки).
• Метод заміни повертає той самий об'єкт String, якщо обидва параметри однакові

Для тих, хто цікавиться, як зламати незмінність рядків на Java ...

Код

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();
        }

    }
}

Вихідні дані

true
I am   mutable
I am   mutable

Рядок є непорушним . Що означає, що ми можемо лише змінити посилання .

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

У Java до об'єктів, як правило, звертаються за посиланнями. У вашому фрагменті коду str є посилання, яке спочатку присвоюється "Hello" (автоматично створений об'єкт або отриманий з нього) постійного пулу ), а потім ви присвоїли інший об'єкт "Help!" до тієї ж довідки. Слід зазначити, що посилання є однаковим і модифікованим, але об'єкти різні. Ще одна річ у вашому коді ви отримали доступ до трьох об’єктів,

1. Коли ви зателефонували до нового String ().
2. Коли вам призначили "привіт".
3. Коли вам призначили "допомогу!".

Виклик нового String () створює новий об'єкт, навіть якщо він існує в пуловому рядку, тому його, як правило, не слід використовувати. Щоб поставити рядок, створений з нового String (), у пул рядків, ви можете спробуватиintern() метод.

Я сподіваюся, що це допомагає.

Незмінність Я можу сказати, що ви не можете змінити саму струну. Припустимо, у вас є String x, значення якого "abc". Тепер ви не можете змінити String, тобто ви не можете змінити жоден символ / s в "abc".

Якщо вам доведеться змінити будь-який символ / символи в String, ви можете використовувати масив символів і змінити його або використовувати 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);

Вихід:

hj
sj

Або ви можете спробувати:

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());
 }
 }

Це покаже, як змінюється хеш-код.

Рядок незмінний означає, що ви не можете змінити сам об'єкт, але ви можете змінити посилання на об'єкт. Коли ви викликали a = "ty", ви фактично змінюєте посилання на новий об'єкт, створений буквальним рядком "ty". Зміна об'єкта означає використовувати його методи для зміни одного з його полів (або поля є загальнодоступними та не остаточними, щоб їх можна було оновити ззовні без доступу до них за допомогою методів), наприклад:

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

Перебуваючи в класі, що змінюється (оголошено остаточним, щоб запобігти зміні через успадкування) (його методи не можуть змінювати свої поля, а також поля завжди є приватними і рекомендується бути остаточними), наприклад, String, ви не можете змінити поточний рядок, але ви може повернути нову рядок, тобто:

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"

Тут незмінність означає, що екземпляр може вказувати на іншу посилання, але початковий вміст рядка не буде змінено в початковій посилання. Дозвольте пояснити на першому прикладі, поданому вами. Перша стрічка вказує на "Привіт", її "Ok upto this". Вдруге його вказівка ​​на "Допомога!". Тут str почав вказувати на "Допомога!" і посилання рядка "Привіт" втрачено, і ми не можемо повернути це.

Насправді, коли str намагатиметься змінити існуючий вміст, тоді буде створена ще одна нова рядок і str почне вказувати на це посилання. Таким чином, ми бачимо, що рядок в початковій посилання не модифікується, але це безпечно при його посиланні, і примірник об'єкта почав вказувати на іншу посилання, тому незмінність зберігається.

Супер пізно до відповіді, але хотів поставити стисле повідомлення від автора класу String на Java

Струни постійні; їх значення не можуть бути змінені після їх створення. Буферні рядки підтримують змінні рядки. Оскільки рядкові об'єкти є незмінними, ними можна ділитися.

З цієї документації можна отримати те, що все, що змінює рядок, повертає інший об'єкт (який може бути новим, інтернованим і старим). Не настільки тонкий натяк на це має виходити з підпису функції. Подумайте над цим: "Чому вони змусили функцію об'єкта повертати об'єкт замість статусу?".

public String replace(char oldChar, char newChar) 

Також ще одне джерело, яке робить цю поведінку явною (З документації щодо функції заміни)

Повертає новий рядок, що виникає в результаті заміни всіх входжень oldChar у цій рядку на новийChar.

Джерело: https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#replace(char,%20char)

• автор Лі Бойтон
• автор Артур ван Гофф
• автор Мартін Бухгольц
• автор Ульф Зібіс

Джерело: JavaDoc of String

Строка "Об'єкт" - сама методика робиться "непорушною". Ця дія не призводить до змін: "letters.replace (" bbb "," aaa ");"

Але присвоєння даних призводить до зміни змісту рядків:

    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);

// Хеш-код рядка Об'єкт не змінюється.

Якщо HELLOваша рядок , то ви не можете змінити HELLOдо HILLO. Ця властивість називається властивістю незмінності.

Ви можете мати кілька змінних String String до точки HELLO String.

Але якщо HELLO char Array, то ви можете змінити HELLO на HILLO. Наприклад,

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

Мови програмування мають незмінні змінні даних, щоб їх можна було використовувати як ключі у ключі, значенні пари.

Я б пояснив це простим прикладом

врахуйте будь-який масив символів: наприклад, char a [] = {'h', 'e', ​​'l', 'l', 'o'}; і рядок: String s = "привіт";

на масиві символів ми можемо виконувати такі операції, як друк лише останніх трьох літер, використовуючи ітерацію масиву; але в рядку ми повинні створити новий об'єкт String і скопіювати необхідну підрядку, і її адреса буде в новому рядковому об'єкті.

напр

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

тому s2 матиме "hel";

Рядок у Java в Immutable and Final означає, що його неможливо змінити чи змінити:

Випадок 1:

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

Вихід: ABC

Причина: Сторінка посилання на об'єкт не змінена, фактично створюється новий об'єкт "DEF", який знаходиться в пулі і взагалі не має посилання (тобто втрачений).

Випадок 2:

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

Вихід: ABCDEF

Причина: У цьому випадку str тепер посилається на новий об'єкт "ABCDEF", отже він друкує ABCDEF, тобто попередній об'єкт str "ABC" втрачається в пулі без посилання.

Оскільки String є незмінним, то зміни не відбудуться, якщо ви не присвоїте повернене значення функції string.so у вашому запитанні присвоєння значення функції swap поверненому значенню s.

s = swap (s, n1, n2); тоді значення рядка s зміниться.

Я також отримував незмінене значення, коли я писав програму, щоб отримати рядок перестановок (хоча він не дає всіх перестановок, але це, наприклад, щоб відповісти на ваше запитання)

Ось приклад.

> 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();
> } }

але я не отримував перетворених значень рядка зверху кодом. Отже, я призначив повернене значення функції swap для рядка і отримав змінені значення рядка. після присвоєння повернутого значення я отримав перестановлені значення рядка.

/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());
    }
}

Виробляю поставити щось подібне

1419358369 1419358369

103056 65078777

Призначення об'єкта Immutable полягає в тому, що його значення не повинно бути змінено один раз присвоєному. Він буде повертати новий об'єкт щоразу, коли ви намагаєтесь змінити його на основі реалізації. Примітка. Щоб уникнути цього, можна використовувати Stringbuffer, а не рядок.

На ваше останнє питання :: u матиме одну посилання та 2 рядки в пулі рядків .. За винятком посилання, вказуватиме на m! Ss! Ss! Pp!