Immutabilità delle stringhe in Java

Considera il seguente esempio.

String str = new String();

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

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

Ora, in Java, gli oggetti String sono immutabili. Allora come strmai all'oggetto può essere assegnato il valore "Aiuto!". Ciò non contraddice l'immutabilità delle stringhe in Java? Qualcuno può spiegarmi l'esatto concetto di immutabilità?

Modificare:

Ok. Ora sto ricevendo, ma solo una domanda di follow-up. Che dire del seguente codice:

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

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

Questo significa che vengono nuovamente creati due oggetti ("Mississippi" e "M! Ss! Ss! Pp!") E che il riferimento strpunta a un oggetto diverso dopo il replace()metodo?

strnon è un oggetto, è un riferimento a un oggetto. "Hello"e "Help!"sono due Stringoggetti distinti . Pertanto, str punta a una stringa. Puoi cambiare ciò a cui punta , ma non ciò a cui punta .

Prendi questo codice, ad esempio:

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

Ora, non c'è niente di ¹ potremmo fare per s1questo sarebbe influenzare il valore di s2. Si riferiscono allo stesso oggetto - la stringa "Hello"- ma quell'oggetto è immutabile e quindi non può essere modificato.

Se facciamo qualcosa del genere:

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

Qui vediamo la differenza tra la mutazione di un oggetto e la modifica di un riferimento. s2punta ancora allo stesso oggetto su cui inizialmente abbiamo s1puntato. Impostazione s1di "Help!"cambia solo il riferimento , mentre l' Stringoggetto originariamente cui rimane invariato.

Se le stringhe fossero mutabili, potremmo fare qualcosa del genere:

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"

Modifica per rispondere alla modifica dell'OP:

Se guardi il codice sorgente di String.replace (char, char) (disponibile anche in src.zip nella directory di installazione di JDK - un suggerimento professionale è quello di guardare lì ogni volta che ti chiedi come funziona davvero qualcosa) puoi vedere che cosa lo fa è il seguente:

• Se oldCharnella stringa corrente sono presenti una o più occorrenze , crea una copia della stringa corrente in cui tutte le occorrenze di oldCharvengono sostituite newChar.
• Se oldCharnon è presente nella stringa corrente, restituisce la stringa corrente.

Quindi sì, "Mississippi".replace('i', '!')crea un nuovo Stringoggetto. Ancora una volta, vale quanto segue:

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

I compiti per ora sono vedere cosa fa il codice sopra se cambi s1 = s1.replace('i', '!');in s1 = s1.replace('Q', '!');:)

¹ In realtà, è possibile mutare stringhe (e altri oggetti immutabili). Richiede riflessione ed è molto, molto pericoloso e non dovrebbe mai essere usato a meno che non sia effettivamente interessato a distruggere il programma.

L'oggetto a cui fa strriferimento può cambiare, ma gli Stringoggetti reali stessi non possono cambiare .

Gli Stringoggetti che contengono la stringa "Hello"e "Help!"non possono modificarne i valori, quindi sono immutabili.

L'immutabilità degli Stringoggetti non significa che i riferimenti che puntano all'oggetto non possano cambiare.

Un modo in cui si può impedire la strmodifica del riferimento è dichiararlo come final:

final String STR = "Hello";

Ora, cercando di assegnare un altro Stringa STRcauserà un errore di compilazione.

Light_handle Ti consiglio di leggere le dimensioni della tazza, una storia sulle variabili e il valore per passaggio, per favore (dimensione della tazza continua) . Questo sarà di grande aiuto nella lettura dei post sopra.

Li hai letti? Sì. Buona.

String str = new String();

Questo crea un nuovo "telecomando" chiamato " str" e lo imposta sul valore new String()(o "").

ad es. in memoria questo crea:

str --- > ""

str  = "Hello";

Questo quindi modifica il telecomando " str" ma non modifica la stringa originale "".

ad es. in memoria questo crea:

str -+   ""
     +-> "Hello"

str = "Help!";

Ciò modifica quindi il " str" telecomando, ma non modifica la stringa originale ""o l'oggetto a cui il telecomando attualmente punta.

ad es. in memoria questo crea:

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

Rompiamolo in alcune parti

String s1 = "hello";

Questa istruzione crea una stringa contenente ciao e occupa spazio nella memoria, ad esempio nel pool di stringhe costanti, e la assegna all'oggetto di riferimento s1

String s2 = s1;

Questa istruzione assegna la stessa stringa ciao al nuovo riferimento s2

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

Entrambi i riferimenti puntano alla stessa stringa, quindi emettono lo stesso valore come segue.

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

Sebbene String sia immutabile , l'assegnazione può essere possibile in modo che s1 faccia ora riferimento al nuovo stack di valori .

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

Ma che dire dell'oggetto s2 che punta a ciao sarà come è.

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

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

Poiché String è immutabile Java Virtual Machine non ci permetterà di modificare la stringa s1 con il suo metodo. Creerà tutti i nuovi oggetti String nel pool come segue.

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

Nota se String sarebbe mutabile, l'output sarebbe stato

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

Ora potresti essere sorpreso dal fatto che String abbia metodi come concat () da modificare. Il frammento seguente cancella la tua confusione.

s1 = s1.concat(" overflow");

Qui stiamo assegnando il valore modificato della stringa al riferimento s1 .

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


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

Ecco perché Java ha deciso che String è una classe finale Altrimenti chiunque può modificare e cambiare il valore di stringa. Spero che questo possa aiutare un po '.

L'oggetto stringa a cui fa riferimento per la prima volta strnon è stato modificato, tutto quello che hai fatto è stato fare strriferimento a un nuovo oggetto stringa.

La stringa non cambierà, il riferimento ad essa cambierà. Stai confondendo l'immutabilità con il concetto di finalcampi. Se un campo viene dichiarato come final, una volta assegnato, non può essere riassegnato.

Per quanto riguarda la parte di sostituzione della tua domanda, prova questo:

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!

Sebbene Java cerchi di ignorarlo, strnon è altro che un puntatore. Ciò significa che quando scrivi per la prima volta str = "Hello";, crei un oggetto a cui strpunta. Quando si riassegna strscrivendo str = "Help!";, viene creato un nuovo oggetto e il vecchio "Hello"oggetto viene raccolto in modo inutile ogni volta che Java ne ha voglia.

L'immutabilità implica che il valore di un oggetto istanziato non può cambiare, non puoi mai trasformare "Ciao" in "Aiuto!".

La variabile str è un riferimento a un oggetto, quando si assegna un nuovo valore a str non si modifica il valore dell'oggetto a cui fa riferimento, si fa riferimento a un oggetto diverso.

La classe String è immutabile e non è possibile modificare il valore dell'oggetto immutabile. Ma nel caso di String, se si modifica il valore di string, questo creerà una nuova stringa nel pool di stringhe e quindi il riferimento della stringa a quel valore non a quello precedente. quindi in questo modo la stringa è immutabile. Facciamo il tuo esempio,

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

creerà una stringa "Mississippi" e la aggiungerà al pool di stringhe, quindi ora str punta al Mississippi.

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

Ma dopo l'operazione sopra, verrà creata un'altra stringa "M! Ss! Ss! Pp!" e verrà aggiunto al pool di stringhe. e ora str sta indicando M! ss! ss! pp !, non Mississippi.

in questo modo, quando modificherai il valore dell'oggetto stringa, creerà un altro oggetto e lo aggiungerà al pool di stringhe.

Facciamo un altro esempio

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

questa riga sopra tre aggiungerà tre oggetti di stringa al pool di stringhe.
1) Ciao
2) Mondo
3) HelloWorld

Uso:

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

Se vedi qui uso il concatmetodo per cambiare la stringa originale, ovvero "Nuova stringa" con una stringa "Aggiunta stringa", ma ho ancora ottenuto l'output come precedente, quindi dimostra che non puoi cambiare il riferimento dell'oggetto della classe String, ma se lo fai con la classe StringBuilder funzionerà. È elencato di seguito.

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

Come ha detto Linus Tolvards:

Parlare è economico. Mostrami il codice

Guarda questo:

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

L'output è

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

Quindi, ricorda due cose:

• Le stringhe sono immutabili fino a quando non si applica un metodo che manipola e ne crea uno nuovo (casi c & d).
• Il metodo Replace restituisce lo stesso oggetto String se entrambi i parametri sono uguali

Per coloro che si chiedono come rompere l'immutabilità delle stringhe in Java ...

Codice

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

    }
}

Produzione

true
I am   mutable
I am   mutable

La stringa è immutabile . Ciò significa che possiamo solo cambiare il riferimento .

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

In Java, gli oggetti sono generalmente accessibili tramite riferimenti. Nel tuo pezzo di codice str è un riferimento che viene prima assegnato a "Hello" (un oggetto creato automaticamente o recuperato da un pool costante ) e quindi hai assegnato un altro oggetto "Aiuto!" allo stesso riferimento. Un punto da notare è che il riferimento è lo stesso e modificato, ma gli oggetti sono diversi. Un'altra cosa nel tuo codice hai avuto accesso a tre oggetti,

1. Quando hai chiamato new String ().
2. Quando hai assegnato "ciao".
3. Quando hai assegnato "aiuto!".

La chiamata di new String () crea un nuovo oggetto anche se esiste nel pool di stringhe, quindi generalmente non dovrebbe essere usato. Per inserire una stringa creata dal nuovo String () nel pool di stringhe puoi provare il intern()metodo.

Spero che aiuti.

L'immutabilità che posso dire è che non puoi cambiare la stringa stessa. Supponiamo di avere String x, il cui valore è "abc". Ora non è possibile modificare la stringa, ovvero non è possibile modificare alcun carattere / i in "abc".

Se è necessario modificare qualsiasi carattere / i nella stringa, è possibile utilizzare un array di caratteri e modificarlo o utilizzare 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);

Produzione:

hj
sj

Oppure puoi provare:

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

Questo mostrerà come cambia l'hashcode.

String è immutabile significa che non è possibile modificare l'oggetto stesso, ma è possibile modificare il riferimento all'oggetto. Quando hai chiamato a = "ty", stai effettivamente cambiando il riferimento di a a un nuovo oggetto creato dal valore letterale "ty" della stringa. Cambiare un oggetto significa usare i suoi metodi per cambiare uno dei suoi campi (oppure i campi sono pubblici e non finali, in modo che possano essere aggiornati dall'esterno senza accedervi tramite metodi), ad esempio:

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

Mentre ci si trova in una classe immutabile (dichiarata come finale, per impedire la modifica tramite ereditarietà) (i suoi metodi non possono modificare i suoi campi e anche i campi sono sempre privati ​​e si consiglia di essere finali), ad esempio String, non è possibile modificare la stringa corrente ma può restituire una nuova stringa, ovvero:

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"

Qui l'immutabilità significa che l'istanza può puntare ad altro riferimento ma il contenuto originale della stringa non verrebbe modificato al riferimento originale. Lasciami spiegare con il primo esempio che hai dato. La prima str sta puntando a "Hello", va bene fino a questo. La seconda volta indica "Aiuto!". Qui str ha iniziato a indicare "Aiuto!" e il riferimento della stringa "Hello" è perso e non riusciamo a recuperarlo.

Infatti quando str tenterà di modificare il contenuto esistente, verrà generata un'altra nuova stringa e str inizierà a puntare a quel riferimento. Quindi vediamo che la stringa al riferimento originale non è modificata ma è sicura al suo riferimento e l'istanza dell'oggetto ha iniziato a puntare a un riferimento diverso, quindi l'immutabilità è preservata.

Super tardi alla risposta, ma volevo mettere un messaggio conciso dall'autore della classe String in Java

Le stringhe sono costanti; i loro valori non possono essere modificati dopo la loro creazione. I buffer di stringhe supportano stringhe mutabili. Poiché gli oggetti String sono immutabili, possono essere condivisi.

Da questa documentazione si può ricavare che tutto ciò che cambia stringa, restituisce oggetti diversi (che potrebbero essere nuovi o internati e vecchi). Il suggerimento non così sottile dovrebbe provenire dalla firma della funzione. Pensaci: "Perché hanno fatto in modo che una funzione su un oggetto restituisse un oggetto anziché lo stato?".

public String replace(char oldChar, char newChar) 

Anche un'altra fonte che rende esplicito questo comportamento (da sostituire la documentazione della funzione)

Restituisce una nuova stringa risultante dalla sostituzione di tutte le occorrenze di oldChar in questa stringa con newChar.

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

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

Fonte: JavaDoc di String.

La stringa Object - i metodi stessi sono resi "immutabili". Questa azione non produce modifiche: "letters.replace (" bbb "," aaa ");"

Ma l'assegnazione dei dati provoca modifiche al contenuto di Stringhe:

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

// L'hashcode della stringa Object non cambia.

Se HELLOè la vostra String allora non si può cambiare HELLOa HILLO. Questa proprietà si chiama proprietà di immutabilità.

Puoi avere più variabili String puntatore per puntare HELLO String.

Ma se HELLO è Char array, allora puoi cambiare HELLO in HILLO. Per esempio,

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

I linguaggi di programmazione hanno variabili di dati immutabili in modo che possano essere utilizzati come chiavi in ​​coppia, coppia di valori.

Lo spiegherei con un semplice esempio

considera qualsiasi matrice di caratteri: ad esempio char a [] = {'h', 'e', ​​'l', 'l', 'o'}; e una stringa: String s = "ciao";

sull'array di caratteri possiamo eseguire operazioni come la stampa delle ultime tre lettere usando l'iterazione dell'array; ma nella stringa dobbiamo creare un nuovo oggetto String e copiare la sottostringa richiesta e il suo indirizzo sarà nel nuovo oggetto stringa.

per esempio

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

così s2 avrà "hel";

La stringa in Java in Immutable e Final significa solo che non può essere cambiata o modificata:

Caso 1:

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

Uscita: ABC

Motivo: l'oggetto str di riferimento non viene modificato, infatti viene creato un nuovo oggetto "DEF" che si trova nel pool e non ha alcun riferimento (vale a dire perso).

Caso 2:

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

Uscita: ABCDEF

Motivo: in questo caso str ora fa riferimento a un nuovo oggetto "ABCDEF", quindi stampa ABCDEF, ovvero l'oggetto precedente str "ABC" viene perso nel pool senza riferimenti.

Poiché String è immutabile, non si verificheranno modifiche se non si assegnerà il valore restituito della funzione a string.so nella domanda, assegnare il valore della funzione di scambio restituito a s.

s = swap (s, n1, n2); quindi il valore della stringa s cambierà.

Stavo anche ottenendo il valore invariato quando stavo scrivendo il programma per ottenere alcune stringhe di permutazioni (anche se non fornisce tutte le permutazioni ma questo è ad esempio per rispondere alla tua domanda)

Ecco un esempio

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

ma non stavo ottenendo i valori permutati della stringa dal codice sopra. Quindi ho assegnato il valore restituito della funzione di scambio alla stringa e ho cambiato i valori della stringa. dopo aver assegnato il valore restituito ho ottenuto i valori consentiti di stringa.

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

Produrrà qualcosa di simile

1419358369 1419358369

103056 65078777

Scopo dell'oggetto Immutabile è che il suo valore non deve essere modificato una volta assegnato. Restituirà un nuovo oggetto ogni volta che si tenta di modificarlo in base all'implementazione. Nota: Stringbuffer invece di string può essere usato per evitarlo.

Alla tua ultima domanda :: avrai un riferimento e 2 stringhe nel pool di stringhe. Tranne il riferimento punterà a m! Ss! Ss! Pp!