Immuabilité des chaînes en Java

Prenons l'exemple suivant.

String str = new String();

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

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

Maintenant, en Java, les objets String sont immuables. Alors comment se fait-il que l'objet strpuisse se voir attribuer la valeur "Aide!". N'est-ce pas en contradiction avec l'immuabilité des chaînes en Java? Quelqu'un peut-il m'expliquer le concept exact d'immuabilité?

Éditer:

D'accord. Je comprends maintenant, mais une seule question complémentaire. Qu'en est-il du code suivant:

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

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

Est-ce à dire que deux objets sont à nouveau créés ("Mississippi" et "M! Ss! Ss! Pp!") Et que la référence strpointe vers un objet différent après la replace()méthode?

strn'est pas un objet, c'est une référence à un objet. "Hello"et "Help!"sont deux Stringobjets distincts . Ainsi, str pointe vers une chaîne. Vous pouvez modifier ce vers quoi il pointe , mais pas ce vers quoi il pointe .

Prenez ce code, par exemple:

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

Maintenant, il n'y a rien ¹ que nous pourrions faire pour s1cela affecter la valeur s2. Ils se réfèrent au même objet - la chaîne "Hello"- mais cet objet est immuable et ne peut donc pas être modifié.

Si nous faisons quelque chose comme ça:

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

Ici, nous voyons la différence entre muter un objet et changer une référence. s2pointe toujours vers le même objet que celui que nous avions initialement défini s1. La définition s1de "Help!"ne modifie que la référence , tandis que l' Stringobjet auquel il faisait référence à l'origine reste inchangé.

Si les chaînes étaient mutables, nous pourrions faire quelque chose comme ceci:

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"

Modifier pour répondre à la modification de OP:

Si vous regardez le code source de String.replace (char, char) (également disponible dans src.zip dans votre répertoire d'installation JDK - une astuce pro consiste à y regarder chaque fois que vous vous demandez comment quelque chose fonctionne vraiment), vous pouvez voir que ce c'est le cas:

• S'il y a une ou plusieurs occurrences de oldChardans la chaîne en cours, faites une copie de la chaîne en cours où toutes les occurrences de oldCharsont remplacées par newChar.
• Si le oldCharn'est pas présent dans la chaîne actuelle, renvoyez la chaîne actuelle.

Alors oui, "Mississippi".replace('i', '!')crée un nouvel Stringobjet. Encore une fois, ce qui suit tient:

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

Votre devoir pour l'instant est de voir ce que fait le code ci-dessus si vous changez s1 = s1.replace('i', '!');en s1 = s1.replace('Q', '!');:)

¹ En fait, il est possible de muter des chaînes (et d'autres objets immuables). Il nécessite une réflexion et est très, très dangereux et ne devrait jamais être utilisé à moins que vous ne souhaitiez réellement détruire le programme.

L'objet strréférencé peut changer, mais pas les Stringobjets réels eux-mêmes.

Les Stringobjets contenant la chaîne "Hello"et "Help!"ne peuvent pas changer leurs valeurs, ils sont donc immuables.

L'immuabilité des Stringobjets ne signifie pas que les références pointant vers l'objet ne peuvent pas changer.

Une façon d'empêcher la strréférence de changer est de la déclarer comme final:

final String STR = "Hello";

Maintenant, en essayant d'assigner une autre Stringà STRprovoquera une erreur de compilation.

Light_handle Je vous recommande de lire la taille de la tasse - une histoire sur les variables et le passage par valeur s'il vous plaît (la taille de la tasse continue) . Cela vous sera très utile lors de la lecture des articles ci-dessus.

Les avez-vous lus? Oui. Bien.

String str = new String();

Cela crée une nouvelle "télécommande" appelée " str" et la définit sur la valeur new String()(ou "").

par exemple en mémoire cela crée:

str --- > ""

str  = "Hello";

Cela modifie alors la télécommande " str" mais ne modifie pas la chaîne d'origine "".

par exemple en mémoire cela crée:

str -+   ""
     +-> "Hello"

str = "Help!";

Cela modifie alors la télécommande " str" mais ne modifie pas la chaîne d'origine ""ou l'objet vers lequel la télécommande pointe actuellement.

par exemple en mémoire cela crée:

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

Permet de le briser en quelques parties

String s1 = "hello";

Cette déclaration crée une chaîne contenant bonjour et occupe de l'espace en mémoire, c'est-à-dire dans le pool de chaînes constant , et l'affecte à l'objet de référence s1

String s2 = s1;

Cette instruction affecte la même chaîne bonjour à la nouvelle référence s2

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

Les deux références pointent vers la même chaîne, donc affichez la même valeur comme suit.

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

Bien que la chaîne soit immuable , l'affectation peut être possible, donc le s1 fera désormais référence à une nouvelle pile de valeurs .

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

Mais qu'en est-il de l' objet s2 qui pointe vers bonjour ce sera comme ça.

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

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

La chaîne étant immuable, la machine virtuelle Java ne nous permettra pas de modifier la chaîne s1 par sa méthode. Il créera tout nouvel objet String dans le pool comme suit.

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

Notez que si String devait être mutable, la sortie aurait été

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

Maintenant, vous pourriez être surpris de savoir pourquoi String a des méthodes telles que concat () à modifier. L'extrait suivant effacera votre confusion.

s1 = s1.concat(" overflow");

Ici, nous attribuons la valeur modifiée de la chaîne à la référence s1 .

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


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

C'est pourquoi Java a décidé que String était une classe finale. Sinon, n'importe qui peut modifier et changer la valeur de string. J'espère que cela vous aidera un peu.

L'objet chaîne qui a été référencé pour la première fois strn'a pas été modifié, vous n'avez fait que faire strréférence à un nouvel objet chaîne.

La chaîne ne changera pas, la référence y sera. Vous confondez l'immuabilité avec le concept de finalchamps. Si un champ est déclaré comme final, une fois qu'il a été attribué, il ne peut pas être réaffecté.

En ce qui concerne la partie remplacer de votre question, essayez ceci:

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!

Bien que java essaie de l'ignorer, strn'est rien de plus qu'un pointeur. Cela signifie que lorsque vous écrivez pour la première fois str = "Hello";, vous créez un objet qui strpointe vers. Lorsque vous réaffectez stren écrivant str = "Help!";, un nouvel objet est créé et l'ancien "Hello"objet est récupéré à chaque fois que java en a envie.

L'immuabilité implique que la valeur d'un objet instancié ne peut pas changer, vous ne pouvez jamais transformer "Bonjour" en "Aide!".

La variable str est une référence à un objet, lorsque vous affectez une nouvelle valeur à str, vous ne modifiez pas la valeur de l'objet qu'elle référence, vous faites référence à un autre objet.

La classe de chaîne est immuable et vous ne pouvez pas modifier la valeur de l'objet immuable. Mais dans le cas de String, si vous modifiez la valeur de string, cela créera une nouvelle chaîne dans le pool de chaînes et votre référence de chaîne à cette valeur n'est pas la plus ancienne. de cette façon, la chaîne est immuable. Prenons votre exemple,

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

il créera une chaîne "Mississippi" et l'ajoutera au pool de chaînes alors maintenant str pointe vers le Mississippi.

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

Mais après l'opération ci-dessus, une autre chaîne sera créée "M! Ss! Ss! Pp!" et il sera ajouté au pool de chaînes. et maintenant str pointe sur M! ss! ss! pp !, pas sur le Mississippi.

de cette façon, lorsque vous modifierez la valeur de l'objet chaîne, il créera un objet supplémentaire et l'ajoutera au pool de chaînes.

Permet d'avoir un exemple de plus

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

cette ligne au-dessus de trois ajoutera trois objets de chaîne au pool de chaînes.
1) Bonjour
2) Monde
3) BonjourWorld

Utilisation:

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

Si vous voyez ici, j'utilise la concatméthode pour changer la chaîne d'origine, c'est-à-dire "Nouvelle chaîne" avec une chaîne "Chaîne ajoutée", mais j'ai quand même obtenu la sortie comme précédemment, donc cela prouve que vous ne pouvez pas changer la référence de l'objet de la classe String, mais si vous faites cette chose par la classe StringBuilder, cela fonctionnera. Il est répertorié ci-dessous.

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

Comme l'a dit Linus Tolvards:

Parler n'est pas cher. Montrez-moi le code

Regarde ça:

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

La sortie est

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

Souvenez-vous donc de deux choses:

• Les chaînes sont immuables jusqu'à ce que vous appliquiez une méthode qui manipule et crée une nouvelle (cas c & d).
• La méthode replace renvoie le même objet String si les deux paramètres sont identiques

Pour ceux qui se demandent comment briser l'immuabilité des chaînes en Java ...

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

    }
}

Production

true
I am   mutable
I am   mutable

La chaîne est immuable . Ce qui signifie que nous ne pouvons que changer la référence .

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

En Java, les objets sont généralement accessibles par des références. Dans votre morceau de code str est une référence qui est d'abord affectée à "Bonjour" (un objet créé automatiquement ou récupéré à partir d' un pool constant ), puis vous avez affecté un autre objet "Aide!" à la même référence. Un point à noter est que la référence est la même et modifiée, mais les objets sont différents. Encore une chose dans votre code, vous avez accédé à trois objets,

1. Lorsque vous avez appelé new String ().
2. Lorsque vous avez attribué "bonjour".
3. Lorsque vous avez attribué "aide!".

L'appel de new String () crée un nouvel objet même s'il existe dans le pool de chaînes, il ne doit donc généralement pas être utilisé. Pour placer une chaîne créée à partir de new String () dans le pool de chaînes, vous pouvez essayer la intern()méthode.

J'espère que ça aide.

L'immuabilité, je peux dire, c'est que vous ne pouvez pas changer la chaîne elle-même. Supposons que vous ayez String x, dont la valeur est "abc". Maintenant, vous ne pouvez pas changer la chaîne, c'est-à-dire que vous ne pouvez pas changer de caractère / s dans "abc".

Si vous devez modifier des caractères dans la chaîne, vous pouvez utiliser un tableau de caractères et le muter ou utiliser 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);

Production:

hj
sj

Ou vous pouvez essayer:

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

Cela montrera comment le code de hachage change.

La chaîne est immuable signifie que vous ne pouvez pas modifier l'objet lui-même, mais vous pouvez modifier la référence à l'objet. Lorsque vous appelez a = "ty", vous changez en fait la référence de a à un nouvel objet créé par le littéral String "ty". Changer un objet signifie utiliser ses méthodes pour changer l'un de ses champs (ou les champs sont publics et non définitifs, afin qu'ils puissent être mis à jour de l'extérieur sans y accéder via des méthodes), par exemple:

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

Dans une classe immuable (déclarée comme finale, pour empêcher toute modification via l'héritage) (ses méthodes ne peuvent pas modifier ses champs, et les champs sont toujours privés et recommandés pour être définitifs), par exemple String, vous ne pouvez pas changer la chaîne actuelle mais vous peut retourner une nouvelle chaîne, c'est-à-dire:

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"

Ici, l'immuabilité signifie que l'instance peut pointer vers une autre référence, mais le contenu d'origine de la chaîne ne serait pas modifié à la référence d'origine. Je m'explique par le premier exemple que vous avez donné. La première chaîne pointe vers "Bonjour", c'est OK jusqu'à présent. La deuxième fois, il pointe vers "Aide!". Ici, str a commencé à pointer vers "Aide!" et la référence de la chaîne "Hello" est perdue et nous ne pouvons pas la récupérer.

En fait, lorsque str essaierait de modifier le contenu existant, une autre nouvelle chaîne sera générée et str commencera à pointer vers cette référence. Nous voyons donc que la chaîne à la référence d'origine n'est pas modifiée, mais que sa référence est sûre et que l'instance de l'objet a commencé à pointer vers une référence différente, donc l'immuabilité est conservée.

Super tard pour la réponse, mais je voulais mettre un message concis de l'auteur de la classe String en Java

Les chaînes sont constantes; leurs valeurs ne peuvent pas être modifiées après leur création. Les tampons de chaîne prennent en charge les chaînes mutables. Les objets String étant immuables, ils peuvent être partagés.

Il peut être dérivé de cette documentation que tout ce qui change de chaîne retourne un objet différent (qui pourrait être nouveau ou interné et ancien). L'astuce pas si subtile à ce sujet devrait provenir de la signature de la fonction. Pensez-y, «Pourquoi ont-ils fait une fonction sur un objet renvoyer un objet au lieu de statut?».

public String replace(char oldChar, char newChar) 

Aussi une autre source qui rend ce comportement explicite (à partir de la documentation de la fonction de remplacement)

Renvoie une nouvelle chaîne résultant du remplacement de toutes les occurrences de oldChar dans cette chaîne par newChar.

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

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

Source: JavaDoc de String.

La méthode Object string - methods elle-même est conçue pour être "immuable". Cette action ne produit aucun changement: "letters.replace (" bbb "," aaa ");"

Mais l'attribution de données entraîne des modifications du contenu des chaînes:

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

// Le hashcode de la chaîne Object ne change pas.

Si HELLOc'est votre chaîne, vous ne pouvez pas passer HELLOà HILLO. Cette propriété est appelée propriété d'immuabilité.

Vous pouvez avoir plusieurs variables String pointeur pour pointer HELLO String.

Mais si BONJOUR est un tableau de caractères, vous pouvez changer BONJOUR en HILLO. Par exemple,

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

Les langages de programmation ont des variables de données immuables de sorte qu'ils peuvent être utilisés comme clés dans une paire clé / valeur.

Je l'expliquerais avec un exemple simple

considérez n'importe quel tableau de caractères: par exemple char a [] = {'h', 'e', ​​'l', 'l', 'o'}; et une chaîne: String s = "hello";

sur le tableau de caractères, nous pouvons effectuer des opérations comme imprimer uniquement les trois dernières lettres en utilisant l'itération du tableau; mais dans la chaîne, nous devons créer un nouvel objet chaîne et copier la sous-chaîne requise et son adresse sera dans le nouvel objet chaîne.

par exemple

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

donc s2 aura "hel";

La chaîne en Java dans Immutable et Final signifie simplement qu'elle ne peut pas être changée ou modifiée:

Cas 1:

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

Sortie: ABC

Raison: La référence d'objet str n'est pas modifiée en fait un nouvel objet "DEF" est créé qui est dans le pool et n'a aucune référence (c'est-à-dire perdu).

Cas 2:

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

Sortie: ABCDEF

Raison: dans ce cas, str fait maintenant référence à un nouvel objet "ABCDEF", il imprime donc ABCDEF, c'est-à-dire que l'objet str précédent "ABC" est perdu dans le pool sans référence.

Parce que la chaîne est immuable, les modifications ne se produiront pas si vous n'affectez pas la valeur renvoyée de la fonction à la chaîne.

s = swap (s, n1, n2); alors la valeur de la chaîne s changera.

J'obtenais également la valeur inchangée lorsque j'écrivais le programme pour obtenir une chaîne de permutations (bien qu'il ne donne pas toutes les permutations mais c'est par exemple pour répondre à votre question)

Voici un exemple.

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

mais je n'obtenais pas les valeurs permutées de la chaîne à partir du code ci-dessus. J'ai donc attribué la valeur renvoyée de la fonction d'échange à la chaîne et obtenu des valeurs modifiées de la chaîne. après avoir attribué la valeur retournée, j'ai obtenu les valeurs permutées de la chaîne.

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

Produira quelque chose comme ça

1419358369 1419358369

103056 65078777

Le but de l'objet immuable est que sa valeur ne doit pas être modifiée une fois attribuée. Il renverra un nouvel objet chaque fois que vous essayez de le modifier en fonction de l'implémentation. Remarque: Stringbuffer au lieu de chaîne peut être utilisé pour éviter cela.

Pour votre dernière question: u aura une référence et 2 chaînes dans le pool de chaînes. Sauf que la référence pointera vers m! Ss! Ss! Pp!