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

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

immuable existent, mutable ne le font pas.

en Java, toutes les chaînes sont immuables. Quand vous essayez de modifier un String , ce que vous faites vraiment est de créer un nouveau. Toutefois, lorsque vous utilisez un StringBuilder , vous êtes réellement en modifier le contenu, au lieu d'en créer un nouveau.

Java String s sont immuables.

dans votre premier exemple, vous changez la référence en String , lui assignant ainsi la valeur de deux autres Strings combinés: str + " Morning" .

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

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

• voulez-vous dire la "variable str ?

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

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

la façon la plus poignante d'éprouver la différence serait quelque chose comme ceci:

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

• Mutable :- Variable
• Immuable :- de l'Onu modifiables

---

la chaîne en Java est immuable . Cependant que signifie être mutable dans un contexte de programmation est la première question. Envisager la classe suivante,

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'une de l'attribut, dans l'autre sens, peuvent être mis à jour pour l'instance de la classe puis on dit que c'est mutable. Nous pouvons toujours le faire à la 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 façons nous pouvons créer une chaîne de caractères 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 !";
// ...

,

1. str1 et str2 sont des littéraux de Chaîne qui va être créé en constante Chaîne de la piscine
2. str3 , str4 et str5 sont des objets String qui sont placés dans la mémoire tas
3. str1 = "Hi!"; crée "Hi!" dans le pool de cordes constant et c'est une référence totalement différente de "Hey!" qui str1 se référant plus tôt.

ici nous créons l'objet String literal ou String. Les deux sont différents, je vous suggérerais de lire le post suivant pour en comprendre plus à ce sujet.

• différence entre string object et string literal

dans n'importe quelle déclaration de chaîne, une chose est commune, qu'il ne modifie pas mais il obtient créé ou transférés à d'autres.

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 la chaîne est-elle devenue immuable ?

c'est comportement non changeant, signifie, la valeur une fois attribuée ne peut pas être mise à jour d'une autre manière. La classe String contient en interne des données dans le tableau de caractères. De plus, class est créé pour être immuable. Jetez un oeil à cette stratégie pour définir classe immuable.

"1519360920 un" Déplacement de la la référence ne signifie pas que vous avez changé sa valeur. Il serait mutable si vous pouvez 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 reste le même.

pourquoi StringBuffer est mutable ?

comme vous l'avez déjà deviné, la classe StringBuffer est elle-même mutable comme vous pouvez la mettre à jour est inscrire directement. Similaire à la chaîne de caractères, il contient également de la valeur dans le tableau de caractères et vous pouvez manipuler ce tableau par différentes méthodes i.e. Ajouter, Supprimer, insérer, etc. qui modifie directement le tableau des valeurs des caractères.

ses très facilement expliqué dans ce lien avec setter et getter classe est mutable tandis que la catégorie avec seulement getter est immuable. Voici les détails. http://latest-tutorial.com/2014/11/14/difference-mutable-immutable-objects-java/

objets mutables: lorsque vous avez une référence à une instance d'un objet, le contenu de cette instance peut être modifié

des Objets Immuables: Quand vous avez une référence à une instance d'un objet, le contenu de cette instance ne peut pas être modifié

comprenons cela avec un exemple:

String myString = new String( "old String" );
System.out.println( myString );
myString = new String( "new String" );
System.out.println( myString );

la sortie de ce est:

old String
new String

maintenant nous trouvons que la valeur affichée par la variable myString a changé. Nous avons défini les objets immuables comme étant incapables de changer de valeur, alors que se passe-t-il? Étendons l'exemple encore une fois pour regarder la variable myString plus près.

String myString = new String( "old String" );
String myCache = myString;
System.out.println( "equal: " + myString.equals( myCache ) );
System.out.println( "same:  " + ( myString == myCache ) );
myString = "not " + myString;
System.out.println( "equal: " + myString.equals( myCache ) );
System.out.println( "same:  " + ( myString == myCache ) );

le résultat de l'exécution est:

equal: true
same:  true
equal: false
same:  false

ce que cela montre est que la variable myString fait référence à une nouvelle instance de la classe String. Le contenu de l'objet n'a pas changé; nous avons écarté l'instance et changé notre référence à une nouvelle avec du nouveau contenu.

j'ai modifié le code de william avec un commentaire de sortie 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 , regardez la valeur de str à la fois dans main() et changeStr() , même si u r changeant la valeur de str dans changeStr() il affecte seulement à cette fonction mais dans la fonction principale la valeur n'est pas changée , mais elle n'est pas dans le cas de StringBuffer..

dans la valeur changée de StringBuffer est affecté en tant que global..

donc String est immuable et StringBuffer mutable...

en Simple , ce que u a changé en objet String n'affectera que cette fonction en allant au Pool de String. mais pas Changé...

une variable mutable est une variable dont la valeur peut changer à sa place, alors que dans une variable immuable le changement de valeur ne se produira pas à sa place. Modifier une variable immuable reconstruira la même variable.

Mutable signifie que vous recevrez une enregistrer la même référence pour la variable et modifier son contenu, mais immuable, vous ne pouvez pas modifier le contenu, mais vous déclarer de nouvelles de référence contient la nouvelle et l'ancienne valeur de la variable

Ex Immuable - > String

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

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

sb toujours à la même adresse, j'espère que ce commentaire aide

en Java, toutes les chaînes sont immuables(ne peut pas changer). quand vous essayez de modifier une chaîne de caractères, ce que vous faites vraiment c'est en créer une nouvelle .

comment créer L'objet string

1. l'Aide de la Chaîne littérale

   Strung str= "java";

2. à l'Aide de mots clés,

   Strung string = new String ("java");

3. à l'Aide du tableau des caractères

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

   chaîne helloString = nouvelle chaîne (helloArray);

venir à la Chaîne de l'immutabilité, signifie simplement inmodifiable ou immuable

prenons un exemple

J'initialise la valeur à la chaîne literal s

String s="kumar";

ci-dessous je vais afficher la représentation décimale de l'adresse de localisation en utilisant le hashcode ()

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

il suffit d'Imprimer la valeur d'une chaîne de caractères S

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

Ok, cette fois je suis inittialisant valeur "kumar" à s1

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

OK vérifions en affichant le hashcode de l'objet s1 que nous avons créé

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

OK, 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 ceci ci-dessous le code enfin

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

OUI, si vous voyez des Chaînes de 's' et 's1' avoir le même hashcode parce que la valeur de la rétention par le 's' et 's1' sont les même, c'est - 'kumar'

considérons la chaîne de caractères 's2' et' s3'. ces deux chaînes de caractères hashcode semblent être différentes dans le sens où elles sont toutes deux stockées à un endroit différent. parce que vous voyez, leurs valeurs sont différentes.

puisque s et s1 hashcode sont identiques parce que ces valeurs sont identiques et 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, voyons quelle est la différence entre changeant et immuable.

mutable(changer) vs immuable (il 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());


    }
}

D'autres questions?? veuillez écrire...