Unveränderlichkeit von Strings in Java

Betrachten Sie das folgende Beispiel.

String str = new String();

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

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

In Java sind String-Objekte jetzt unveränderlich. Wie kommt es dann, dass dem Objekt strder Wert "Hilfe!" Zugewiesen werden kann? Widerspricht dies nicht der Unveränderlichkeit von Strings in Java? Kann mir bitte jemand das genaue Konzept der Unveränderlichkeit erklären?

Bearbeiten:

OK. Ich verstehe es jetzt, aber nur eine Folgefrage. Was ist mit dem folgenden Code:

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

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

Bedeutet dies, dass zwei Objekte erneut erstellt werden ("Mississippi" und "M! Ss! Ss! Pp!") Und die Referenz strnach der replace()Methode auf ein anderes Objekt verweist ?

strist kein Objekt, es ist ein Verweis auf ein Objekt. "Hello"und "Help!"sind zwei verschiedene StringObjekte. Zeigt also str auf eine Zeichenfolge. Sie können ändern, auf was es zeigt , aber nicht auf das, worauf es zeigt .

Nehmen Sie diesen Code zum Beispiel:

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

Jetzt gibt es nichts ¹ wir tun könnten , um s1die den Wert beeinflussen würde s2. Sie beziehen sich auf dasselbe Objekt - die Zeichenfolge "Hello"-, aber dieses Objekt ist unveränderlich und kann daher nicht geändert werden.

Wenn wir so etwas machen:

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

Hier sehen wir den Unterschied zwischen dem Mutieren eines Objekts und dem Ändern einer Referenz. s2zeigt immer noch auf dasselbe Objekt, auf das wir ursprünglich s1zeigen wollten. Wenn Sie festlegen s1, dass "Help!"nur die Referenz geändert Stringwird, bleibt das Objekt, auf das ursprünglich verwiesen wurde, unverändert.

Wenn Strings waren wandelbar, könnten wir so etwas tun:

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"

Bearbeiten, um auf die Bearbeitung von OP zu reagieren:

Wenn Sie sich den Quellcode für String.replace (char, char) ansehen (auch in src.zip in Ihrem JDK-Installationsverzeichnis verfügbar - ein Tipp ist, wenn Sie sich fragen, wie etwas wirklich funktioniert), können Sie sehen, was es ist das Folgende:

• Wenn oldChardie aktuelle Zeichenfolge ein oder mehrere Vorkommen von enthält , erstellen Sie eine Kopie der aktuellen Zeichenfolge, durch die alle Vorkommen von oldCharersetzt werden newChar.
• Wenn das oldCharin der aktuellen Zeichenfolge nicht vorhanden ist, geben Sie die aktuelle Zeichenfolge zurück.

Also ja, "Mississippi".replace('i', '!')erstellt ein neues StringObjekt. Auch hier gilt:

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

Ihre Hausaufgabe ist es, zu sehen, was der obige Code bewirkt, wenn Sie s1 = s1.replace('i', '!');zu s1 = s1.replace('Q', '!');:) wechseln.

¹ Eigentlich ist es ist möglich , zu mutieren Strings (und andere unveränderliche Objekte). Es erfordert Reflexion und ist sehr, sehr gefährlich und sollte niemals verwendet werden, es sei denn, Sie sind tatsächlich daran interessiert, das Programm zu zerstören.

Das Objekt, auf das strverwiesen wird, kann sich ändern, die tatsächlichen StringObjekte selbst jedoch nicht.

Die StringObjekte, die die Zeichenfolge enthalten "Hello"und "Help!"ihre Werte nicht ändern können, sind daher unveränderlich.

Die Unveränderlichkeit von StringObjekten bedeutet nicht, dass sich die Verweise auf das Objekt nicht ändern können.

Eine Möglichkeit, die strÄnderung der Referenz zu verhindern , besteht darin, sie wie folgt zu deklarieren final:

final String STR = "Hello";

Wenn Sie nun versuchen, einen anderen zuzuweisen String, STRwird ein Kompilierungsfehler verursacht.

Light_handle Ich empfehle Ihnen, die Cup-Größe zu lesen - eine Geschichte über Variablen und Pass-by-Value Please (Cup-Größe wird fortgesetzt) . Dies wird beim Lesen der obigen Beiträge sehr hilfreich sein.

Hast du sie gelesen? Ja. Gut.

String str = new String();

Dadurch wird eine neue "Fernbedienung" mit dem Namen " str" erstellt und auf den Wert new String()(oder "") gesetzt.

zB im Gedächtnis schafft dies:

str --- > ""

str  = "Hello";

Dadurch wird die Fernbedienung " str" geändert, die ursprüngliche Zeichenfolge wird jedoch nicht geändert "".

zB im Gedächtnis schafft dies:

str -+   ""
     +-> "Hello"

str = "Help!";

Dadurch wird die Fernbedienung " str" geändert , jedoch nicht die ursprüngliche Zeichenfolge ""oder das Objekt, auf das die Fernbedienung derzeit zeigt.

zB im Gedächtnis schafft dies:

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

Lasst es uns in einige Teile zerlegen

String s1 = "hello";

Diese Anweisung erstellt eine Zeichenfolge, die Hallo enthält und Speicherplatz im Speicher belegt, dh im Konstanten Zeichenfolgenpool, und weist sie dem Referenzobjekt s1 zu

String s2 = s1;

Diese Anweisung weist der neuen Referenz s2 dieselbe Zeichenfolge Hallo zu

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

Beide Referenzen verweisen auf dieselbe Zeichenfolge. Geben Sie daher denselben Wert wie folgt aus.

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

Obwohl String ist unveränderlich , kann Zuordnung möglich sein , so dass die s1 nun auf den neuen Wert bezieht Stapel .

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

Aber was ist mit dem s2- Objekt, das auf Hallo zeigt ? Es wird so sein, wie es ist.

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

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

Da String unveränderlich ist , können wir mit Java Virtual Machine den String s1 nicht nach seiner Methode ändern . Das neue String-Objekt im Pool wird wie folgt erstellt.

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

Beachten Sie, wenn String veränderlich wäre, wäre die Ausgabe gewesen

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

Jetzt werden Sie überrascht sein, warum String Methoden wie concat () zum Ändern hat. Das Folgen des Snippets wird Ihre Verwirrung beseitigen.

s1 = s1.concat(" overflow");

Hier weisen wir der s1- Referenz den geänderten Wert des Strings zurück .

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


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

Aus diesem Grund hat Java String als letzte Klasse festgelegt. Andernfalls kann jeder den Wert des Strings ändern. Hoffe das wird ein bisschen helfen.

Das Zeichenfolgenobjekt, auf das zuerst verwiesen wurde, strwurde nicht geändert. Sie haben strlediglich auf ein neues Zeichenfolgenobjekt verwiesen.

Der String ändert sich nicht, der Verweis darauf ändert sich. Sie verwechseln Unveränderlichkeit mit dem Konzept der finalFelder. Wenn ein Feld nach finalseiner Zuweisung als deklariert wird , kann es nicht neu zugewiesen werden.

Versuchen Sie Folgendes, um den Ersatzteil Ihrer Frage zu ersetzen:

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!

Obwohl Java versucht, es zu ignorieren, strist es nichts weiter als ein Zeiger. Dies bedeutet, dass Sie beim ersten Schreiben str = "Hello";ein Objekt erstellen, auf das strverweist. Wenn Sie strdurch Schreiben str = "Help!";eine Neuzuweisung vornehmen , wird ein neues Objekt erstellt und das alte "Hello"Objekt wird mit Müll gesammelt, wenn Java dies wünscht.

Unveränderlichkeit bedeutet, dass sich der Wert eines instanziierten Objekts nicht ändern kann. Sie können "Hallo" niemals in "Hilfe!" Verwandeln.

Die Variable str ist eine Referenz auf ein Objekt. Wenn Sie str einen neuen Wert zuweisen, ändern Sie nicht den Wert des Objekts, auf das sie verweist, sondern auf ein anderes Objekt.

Die Zeichenfolgenklasse ist unveränderlich, und Sie können den Wert des unveränderlichen Objekts nicht ändern. Wenn Sie jedoch im Fall von String den Wert des Strings ändern, wird ein neuer String im String-Pool erstellt, und Ihr String-Verweis auf diesen Wert ist nicht der ältere. Auf diese Weise ist die Zeichenfolge unveränderlich. Nehmen wir Ihr Beispiel,

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

Es wird eine Zeichenfolge "Mississippi" erstellt und zum Zeichenfolgenpool hinzugefügt, sodass str jetzt auf Mississippi zeigt.

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

Nach der obigen Operation wird jedoch eine weitere Zeichenfolge "M! Ss! Ss! Pp!" Erstellt. und es wird zum String-Pool hinzugefügt. und jetzt zeigt str auf M! ss! ss! pp!, nicht auf Mississippi.

Auf diese Weise wird beim Ändern des Werts des Zeichenfolgenobjekts ein weiteres Objekt erstellt und dem Zeichenfolgenpool hinzugefügt.

Lassen Sie uns noch ein Beispiel haben

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

Diese obige drei Zeilen fügen dem String-Pool drei String-Objekte hinzu.
1) Hallo
2) Welt
3) Hallo Welt

Verwenden:

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

Wenn Sie hier sehen, verwende ich die concatMethode, um die ursprüngliche Zeichenfolge, dh "Neue Zeichenfolge", durch eine Zeichenfolge "Hinzugefügte Zeichenfolge" zu ändern, aber ich habe die Ausgabe wie zuvor erhalten, sodass bewiesen wird, dass Sie die Referenz des Objekts nicht ändern können der String-Klasse, aber wenn Sie dies mit der StringBuilder-Klasse tun, wird es funktionieren. Es ist unten aufgeführt.

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

Wie Linus Tolvards sagte:

Reden ist billig. Zeig mir den Code

Schau dir das an:

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

Die Ausgabe ist

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

Denken Sie also an zwei Dinge:

• Zeichenfolgen sind unveränderlich, bis Sie eine Methode anwenden, die eine neue manipuliert und erstellt (C & D-Fälle).
• Die Replace-Methode gibt dasselbe String-Objekt zurück, wenn beide Parameter identisch sind

Für diejenigen, die sich fragen, wie man die Unveränderlichkeit von Strings in Java bricht ...

Code

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

    }
}

Ausgabe

true
I am   mutable
I am   mutable

String ist unveränderlich . Das heißt, wir können nur die Referenz ändern .

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 wird auf Objekte im Allgemeinen über Referenzen zugegriffen. In Ihrem Code befindet sich str eine Referenz, die zuerst "Hallo" zugewiesen wird (ein automatisch erstelltes Objekt oder aus einem konstanten Pool abgerufen ) und dann ein anderes Objekt "Hilfe!" zu derselben Referenz. Ein zu beachtender Punkt ist, dass die Referenz dieselbe und modifizierte ist, die Objekte jedoch unterschiedlich sind. Eine weitere Sache in Ihrem Code, auf die Sie zugegriffen haben, sind drei Objekte:

1. Wenn Sie new String () aufgerufen haben.
2. Wenn Sie "Hallo" zugewiesen haben.
3. Wenn Sie "Hilfe!" Zugewiesen haben.

Durch Aufrufen von new String () wird ein neues Objekt erstellt, auch wenn es im Zeichenfolgenpool vorhanden ist. Daher sollte es im Allgemeinen nicht verwendet werden. Um eine aus new String () erstellte Zeichenfolge in den Zeichenfolgenpool einzufügen, können Sie die intern()Methode ausprobieren .

Ich hoffe das hilft.

Unveränderlichkeit kann ich sagen, dass Sie den String selbst nicht ändern können. Angenommen, Sie haben String x, dessen Wert "abc" ist. Jetzt können Sie den String nicht mehr ändern, dh Sie können keine Zeichen in "abc" ändern.

Wenn Sie Zeichen in der Zeichenfolge ändern müssen, können Sie ein Zeichenarray verwenden und es mutieren oder StringBuilder verwenden.

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

Ausgabe:

hj
sj

Oder Sie können versuchen:

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

Dies zeigt, wie sich der Hashcode ändert.

Zeichenfolge ist unveränderlich bedeutet, dass Sie das Objekt selbst nicht ändern können, aber den Verweis auf das Objekt ändern können. Wenn Sie a = "ty" aufgerufen haben, ändern Sie tatsächlich die Referenz von a auf ein neues Objekt, das durch das String-Literal "ty" erstellt wurde. Das Ändern eines Objekts bedeutet, seine Methoden zum Ändern eines seiner Felder zu verwenden (oder die Felder sind öffentlich und nicht endgültig, sodass sie von außen aktualisiert werden können, ohne über Methoden auf sie zuzugreifen), zum Beispiel:

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

In einer unveränderlichen Klasse (als final deklariert, um Änderungen durch Vererbung zu verhindern) (ihre Methoden können ihre Felder nicht ändern, und auch die Felder sind immer privat und werden als final empfohlen), z. B. String, können Sie den aktuellen String nur Sie selbst ändern kann einen neuen String zurückgeben, dh:

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"

Unveränderlichkeit bedeutet hier, dass die Instanz auf eine andere Referenz verweisen kann, der ursprüngliche Inhalt der Zeichenfolge jedoch bei der ursprünglichen Referenz nicht geändert wird. Lassen Sie mich anhand des ersten von Ihnen gegebenen Beispiels erklären. Die erste Str zeigt auf "Hallo", bis dahin ist es in Ordnung. Zum zweiten Mal zeigt es auf "Hilfe!". Hier zeigte str auf "Hilfe!" und die Referenz von "Hallo" Zeichenfolge geht verloren und wir können das nicht zurückbekommen.

Wenn str versucht, den vorhandenen Inhalt zu ändern, wird eine weitere neue Zeichenfolge generiert, und str zeigt auf diese Referenz. Wir sehen also, dass die Zeichenfolge an der ursprünglichen Referenz nicht geändert wird, aber an ihrer Referenz sicher ist und die Instanz des Objekts auf eine andere Referenz zeigt, sodass die Unveränderlichkeit erhalten bleibt.

Super spät zur Antwort, wollte aber eine kurze Nachricht vom Autor der String-Klasse in Java einfügen

Saiten sind konstant; Ihre Werte können nach ihrer Erstellung nicht mehr geändert werden. String-Puffer unterstützen veränderbare Strings. Da String-Objekte unveränderlich sind, können sie gemeinsam genutzt werden.

Aus dieser Dokumentation kann abgeleitet werden, dass alles, was die Zeichenfolge ändert, ein anderes Objekt zurückgibt (das neu oder intern und alt sein kann). Der nicht so subtile Hinweis dazu sollte aus der Funktionssignatur stammen. Denken Sie darüber nach: "Warum haben sie eine Funktion für ein Objekt dazu gebracht, ein Objekt anstelle des Status zurückzugeben?"

public String replace(char oldChar, char newChar) 

Auch eine weitere Quelle, die dieses Verhalten explizit macht (Aus der Dokumentation der Ersetzungsfunktion)

Gibt eine neue Zeichenfolge zurück, die sich aus dem Ersetzen aller Vorkommen von oldChar in dieser Zeichenfolge durch newChar ergibt.

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

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

Quelle: JavaDoc von String.

Die Object string - Methoden selbst werden als "unveränderlich" festgelegt. Diese Aktion bewirkt keine Änderungen: "letters.replace (" bbb "," aaa ");"

Das Zuweisen von Daten führt jedoch dazu, dass sich Änderungen am Inhalt der Zeichenfolgen ändern:

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

// Der Hashcode des String-Objekts ändert sich nicht.

Wenn HELLOIhr String ist , dann können Sie nicht ändern HELLOzu HILLO. Diese Eigenschaft wird als Unveränderlichkeitseigenschaft bezeichnet.

Sie können mehrere Zeiger-String-Variablen verwenden, um auf HELLO String zu zeigen.

Wenn HELLO jedoch char Array ist, können Sie HELLO in HILLO ändern. Z.B,

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

Programmiersprachen haben unveränderliche Datenvariablen, so dass sie als Schlüssel im Schlüssel-Wert-Paar verwendet werden können.

Ich würde es mit einem einfachen Beispiel erklären

Betrachten Sie ein beliebiges Zeichenarray: zB char a [] = {'h', 'e', ​​'l', 'l', 'o'}; und eine Zeichenfolge: Zeichenfolge s = "Hallo";

Auf Zeichenarrays können wir Operationen ausführen, z. B. nur die letzten drei Buchstaben drucken, indem wir das Array iterieren. Aber in String müssen wir ein neues String-Objekt erstellen und den erforderlichen Teilstring kopieren. Die Adresse befindet sich in einem neuen String-Objekt.

z.B

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

also wird s2 "hel" haben;

String in Java in Immutable und Final bedeutet nur, dass er nicht geändert oder modifiziert werden kann:

Fall 1:

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

Ausgabe: ABC

Grund: Die Objektreferenz str wird nicht geändert, tatsächlich wird ein neues Objekt "DEF" erstellt, das sich im Pool befindet und überhaupt keine Referenz hat (dh verloren geht).

Fall 2:

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

Ausgabe: ABCDEF

Grund: In diesem Fall bezieht sich str jetzt auf ein neues Objekt "ABCDEF", daher wird ABCDEF gedruckt, dh das vorherige str-Objekt "ABC" geht im Pool ohne Referenz verloren.

Da String unveränderlich ist, treten keine Änderungen auf, wenn Sie den zurückgegebenen Wert der Funktion nicht dem String zuweisen. Weisen Sie in Ihrer Frage den Wert der zurückgegebenen Swap-Funktion s zu.

s = swap (s, n1, n2), dann ändert sich der Wert der Zeichenfolge s.

Ich habe auch den unveränderten Wert erhalten, als ich das Programm geschrieben habe, um eine Permutationszeichenfolge zu erhalten (obwohl es nicht alle Permutationen gibt, aber dies ist zum Beispiel, um Ihre Frage zu beantworten).

Hier ist ein Beispiel.

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

Aber ich habe die permutierten Werte der Zeichenfolge nicht aus dem obigen Code erhalten. Also habe ich der Zeichenfolge den zurückgegebenen Wert der Swap-Funktion zugewiesen und die Werte der Zeichenfolge geändert. Nach dem Zuweisen des zurückgegebenen Wertes erhielt ich die permutierten Werte der Zeichenfolge.

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

Wird so etwas produzieren

1419358369 1419358369

103056 65078777

Zweck des unveränderlichen Objekts ist, dass sein Wert nach seiner Zuweisung nicht geändert wird. Jedes Mal, wenn Sie versuchen, es basierend auf der Implementierung zu ändern, wird ein neues Objekt zurückgegeben. Hinweis: Stringbuffer anstelle von String kann verwendet werden, um dies zu vermeiden.

Zu Ihrer letzten Frage :: u hat eine Referenz und 2 Zeichenfolgen im Zeichenfolgenpool. Außer die Referenz zeigt auf m! Ss! Ss! Pp!