web-dev-qa-db-fra.com

Quelle est la différence entre une chaîne mutable et immuable en java

Selon ma connaissance,

une chaîne mutable peut être changée, et une chaîne immuable ne peut pas être changée.

Ici, je veux changer la valeur de String comme ceci,

String str="Good";
str=str+" Morning";

et d'une autre manière est,

StringBuffer str= new StringBuffer("Good");
str.append(" Morning");

Dans les deux cas, j'essaie de modifier la valeur de str. Quelqu'un peut-il me dire quelle est la différence dans les deux cas et me donner une image claire d'objets mutables et immuables.

javastringimmutabilitymutable
41
Raghu

Quelle est la différence entre une chaîne mutable et immuable en Java

immuable existe, mutable ne pas.

11
Philipp Sander

En Java, toutes les chaînes sont immuables. Lorsque vous essayez de modifier une String, vous créez réellement une nouvelle. Toutefois, lorsque vous utilisez une StringBuilder, vous modifiez en fait le contenu au lieu d'en créer un nouveau.

7
Balduz

Les Strings Java sont immuables. 

Dans votre premier exemple, vous remplacez reference par String, en lui affectant la valeur de deux autres Strings combinés: str + " Morning". 

Au contraire, un StringBuilder ou StringBuffer peut être modifié par ses méthodes. 

5
Mena

String en Java est immuable. Cependant, que signifie en premier lieu mutable dans un contexte de programmation? Pensez à suivre le cours,

public class Dimension {
    private int height;

    private int width;

    public Dimenstion() {
    }

    public void setSize(int height, int width) {
        this.height = height;
        this.width = width;
    }

    public getHeight() {
        return height;
    }

    public getWidth() {
        return width;
    }
}

Maintenant, après avoir créé l'instance de Dimension, nous pouvons toujours mettre à jour ses attributs. Notez que si l'un des attributs, dans un autre état du sens, peut être mis à jour, par exemple, de la classe, il est dit qu'il est mutable. On peut toujours faire suite,

Dimension d = new Dimension();
d.setSize(10, 20);// Dimension changed
d.setSize(10, 200);// Dimension changed
d.setSize(100, 200);// Dimension changed

Voyons de différentes manières que nous pouvons créer une chaîne en Java.

String str1 = "Hey!";
String str2 = "Jack";
String str3 = new String("Hey Jack!");
String str4 = new String(new char[] {'H', 'e', 'y', '!'});
String str5 = str1 + str2;
str1 = "Hi !";
// ...

Alors,

  1. str1 et str2 sont des littéraux de chaîne créés dans un pool constant de chaînes
  2. str3, str4 et str5 sont des objets chaîne placés dans la mémoire de tas
  3. str1 = "Hi!"; crée "Hi!" dans le pool constant de chaînes et sa référence est totalement différente de celle de "Hey!" qui str1 faisait référence précédemment.

Nous créons ici le littéral chaîne ou l’objet chaîne. Les deux sont différents, je vous suggère de lire le post suivant pour en savoir plus à ce sujet.

Dans toute déclaration de chaîne, une chose est commune, qu'elle ne soit pas modifiée mais qu'elle soit créée ou transférée à une autre.

String str = "Good"; // Create the String literal in String pool
str = str + " Morning"; // Create String with concatenation of str + "Morning"
|_____________________|
       |- Step 1 : Concatenate "Good"  and " Morning" with StringBuilder
       |- Step 2 : assign reference of created "Good Morning" String Object to str

Comment String est devenu immuable?

Son comportement ne change pas, cela signifie que la valeur une fois attribuée ne peut être mise à jour d'aucune autre manière. La classe String contient en interne des données dans un tableau de caractères. De plus, la classe est créée pour être immuable. Regardez cette stratégie pour définir une classe immuable. 

Déplacer la référence ne signifie pas que vous avez changé sa valeur. Cela serait modifiable si vous pouviez mettre à jour le tableau de caractères qui se trouve derrière la scène dans la classe String. Mais en réalité, ce tableau sera initialisé une fois et tout au long du programme, il restera le même.

Pourquoi StringBuffer est-il mutable?

Comme vous l'avez déjà deviné, la classe StringBuffer est modifiable elle-même car vous pouvez mettre à jour c'est state directement. Similaire à String, il contient également une valeur dans un tableau de caractères et vous pouvez manipuler ce tableau à l'aide de différentes méthodes i.e. ajouter, supprimer, insérer, etc., ce qui change directement le tableau de valeurs de caractères.

3
CoderCroc

Lorsque vous dites str, vous devez faire attention à ce que vous voulez dire:

  • voulez-vous dire la variablestr?

  • ou voulez-vous dire le objet référencé par str?

Dans votre exemple StringBuffer, vous ne modifiez pas la valeur de str et dans votre exemple String, vous ne modifiez pas l'état de l'objet String.

La manière la plus poignante de faire l'expérience de la différence serait la suivante:

static void change(String in) { 
  in = in + " changed";
}

static void change(StringBuffer in) {
  in.append(" changed");
}

public static void main(String[] args) {
   StringBuffer sb = new StringBuffer("value");
   String str = "value";
   change(sb);
   change(str);
   System.out.println("StringBuffer: "+sb);
   System.out.println("String: "+str);
}
3
William F. Jameson

En Java, toutes les chaînes sont immuables (impossible de changer). _ {Lorsque vous essayez de modifier une chaîne, vous créez réellement une nouvelle chaîne}.

En suivant les différentes manières de créer l'objet string

  1. Utilisation du littéral de chaîne

    String str="Java";

  2. Utiliser un nouveau mot clé

    String str = new String("Java");

  3. Utiliser un tableau de caractères

    char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };

String helloString = new String(helloArray);

venir à String immutability, signifie simplement non modifiable ou immuable

Prenons un exemple

J'initialise la valeur au littéral String s

String s="kumar";

Ci-dessous, je vais afficher la représentation décimale de l'adresse de l'emplacement en utilisant hashcode ()

System.out.println(s.hashCode());

Imprimer simplement la valeur d'un String s

System.out.println("value "+s);

D'accord, cette fois je suis en train d'inittialiser la valeur "kumar" en s1

String s1="kumar";   // what you think is this line, takes new location in the memory ???

D'accord vérifions en affichant hashcode de l'objet s1 que nous avons créé

System.out.println(s1.hashCode());

d'accord, vérifions ci-dessous le code

String s2=new String("Kumar");
    System.out.println(s2.hashCode());  // why this gives the different address ??

Ok, vérifiez ce code ci-dessous enfin

String s3=new String("KUMAR");
    System.out.println(s3.hashCode());  // again different address ???

YES, si vous voyez que Strings 's' et 's1' ont le même hashcode parce que la valeur retenue par 's' et 's1' est identique à 'kumar' 

Considérons String 's2' et 's3', ces deux codes de hachage semblent être différents dans le sens où ils ont été stockés dans un emplacement différent, car leurs valeurs sont différentes. 

puisque s et s1, le hashcode est identique car ces valeurs sont identiques et sont stockées au même endroit.

Exemple 1: Essayez ci-dessous le code et analysez ligne par ligne

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

    String s="Java";
    System.out.println(s.hashCode());
    String s1="Java";
    System.out.println(s1.hashCode());
    String s2=new String("Java");
    System.out.println(s2.hashCode());
    String s3=new String("Java");
    System.out.println(s3.hashCode());
}
}

Exemple 2: essayez ci-dessous le code et analysez ligne par ligne

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

        String s="Java";
        s.concat(" programming");  // s can not be changed "immutablity"
        System.out.println("value of s "+s);
        System.out.println(" hashcode of s "+s.hashCode());

        String s1="Java";
        String s2=s.concat(" programming");   // s1 can not be changed "immutablity" rather creates object s2
        System.out.println("value of s1 "+s1);
        System.out.println(" hashcode of s1 "+s1.hashCode());  

        System.out.println("value of s2 "+s2);
        System.out.println(" hashcode of s2 "+s2.hashCode());

    }
}

Ok, regardons quelle est la différence entre mutable et immuable.

mutable (ça change) vs immuable (ça ne peut pas changer)

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


        // it demonstrates immutable concept
        String s="Java";
        s.concat(" programming");  // s can not be changed (immutablity)
        System.out.println("value of s ==  "+s); 
        System.out.println(" hashcode of s == "+s.hashCode()+"\n\n");


        // it demonstrates mutable concept
        StringBuffer s1= new StringBuffer("Java");
        s1.append(" programming");  // s can be changed (mutablity)
        System.out.println("value of s1 ==  "+s1); 
        System.out.println(" hashcode of s1 == "+s1.hashCode());


    }
}

Avez-vous d'autres questions? s'il vous plaît écrivez sur ...

1
KumarK

Mutable signifie que vous sauvegarderez la même référence en variable et que vous en modifierez le contenu, mais que vous ne pouvez pas modifier le contenu, mais vous déclarez une nouvelle référence contient la nouvelle et l'ancienne valeur de la variable

Ex Immutable -> String

String x = "value0ne";// adresse one x += "valueTwo"; //an other adresse {adresse two} adresse sur le changement de mémoire de tas.

Mutable -> StringBuffer - StringBuilder StringBuilder sb = new StringBuilder(); sb.append("valueOne"); // adresse One sb.append("valueTwo"); // adresse One

sb toujours au meme adresse j'espere que ce commentaire aidera

0
Said BAHAOUARY

J'ai modifié le code de william avec une sortie commentaires pour mieux comprendre

   static void changeStr(String in) { 
      in = in+" changed";
      System.out.println("fun:"+in); //value changed 
    }
    static void changeStrBuf(StringBuffer in) {
      in.append(" changed");   //value changed
    }

    public static void main(String[] args) {
       StringBuffer sb = new StringBuffer("value");
       String str = "value";
       changeStrBuf(sb);
       changeStr(str);
       System.out.println("StringBuffer: "+sb); //value changed
       System.out.println("String: "+str);       // value 
    }

Dans le code ci-dessus, examinez la valeur de str dans main () et changeStr (), même si vous modifiez la valeur de str dans changeStr (), cela n'affecte que cette fonction, mais la valeur de la fonction principale n'est pas modifiée. mais pas dans le cas de StringBuffer .. 

Dans StringBuffer, la valeur modifiée est affectée globalement. 

donc String est immuable et StringBuffer est modifiable ...

En Simple, tout ce que vous avez changé en String Object n’affectera que cette fonction En allant dans String Pool. mais pas changé ...

0
Vinay Shanubhag

Une variable mutable est une variable dont la valeur peut changer à la place, alors qu'une variable immuable ne changera pas de valeur La modification d'une variable immuable reconstruira la même variable.

0
Amit Upadhyay