objetos - ¿Cuál es la diferencia entre cadena mutable e inmutable en java?

que es la clase stringbuilder en java

Question

Según mi conocimiento,

una cuerda mutable se puede cambiar, y una cadena inmutable no se puede cambiar.

Aquí quiero cambiar el valor de String así,

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

y de otra manera es,

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

En ambos casos, estoy tratando de alterar el valor de str . ¿Puede alguien decirme cuál es la diferencia en ambos casos y darme una idea clara de los objetos mutables e inmutables?

Answer 1

¿Cuál es la diferencia entre cadena mutable e inmutable en java?

inmutable existe, mutable no.

Answer 2

Caso 1:

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

En el código anterior, crea 3 objetos String .

1. "Bien" va al String Pool .
2. "Mañana" también entra al String Pool .
3. "Buenos días" creado al concatenar "Bueno" y "Mañana". Este tipo va al Heap .

Nota: las cadenas son siempre inmutables . No hay tal cosa como una cadena mutable . str es solo una referencia que eventualmente apunta a "Buenos días". En realidad, no estás trabajando en 1 objeto. tienes 3 objetos de String distintos.

Caso 2

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

StringBuffer contiene una matriz de caracteres. No es lo mismo que una String . El código anterior agrega caracteres a la matriz existente. Efectivamente, StringBuffer es mutable, su representación de String no lo es.

Answer 3

Cuando diga str , debe tener cuidado con lo que quiere decir:

• ¿te refieres a la variable str ?

• ¿o te refieres al objeto al que hace referencia str ?

En su ejemplo de StringBuffer no está alterando el valor de str , y en su ejemplo de String no está alterando el estado del objeto String .

La forma más conmovedora de experimentar la diferencia sería algo como esto:

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

Answer 4

En Java, todas las cadenas son inmutables (no se puede cambiar). Cuando intentas modificar una cadena, lo que realmente estás haciendo es crear una nueva .

De las siguientes maneras podemos crear el objeto de cadena

1. Usando String literal

   Strung str = "java";

2. Usando nueva palabra clave

   Strung str = new String ("java");

3. Usando matriz de caracteres

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

   String helloString = new String (helloArray);

llegar a la inmutabilidad de String, simplemente significa inmodificable o inmutable

Tomemos un ejemplo

Estoy inicializando el valor para el literal de String

String s="kumar";

A continuación voy a mostrar la representación decimal de la dirección de ubicación usando hashcode ()

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

Simplemente imprimiendo el valor de una cadena s

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

De acuerdo, esta vez estoy iniciando el valor "kumar" a s1

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

Bien, vamos a verificar mostrando hashcode del objeto s1 que creamos

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

de acuerdo, revisemos el código a continuación

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

De acuerdo, revisa este código a continuación por fin

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

SÍ, si ve cadenas ''s'' y ''s1'' que tienen el mismo código hash porque el valor retenido por ''s'' y ''s1'' es el mismo que es ''kumar''

Consideremos String ''s2'' y ''s3'' estos dos Strings hashcode parece ser diferente en el sentido, ambos almacenados en una ubicación diferente porque ve que sus valores son diferentes.

ya que s y s1 hashcode son iguales porque esos valores son los mismos y se almacenan en la misma ubicación.

Ejemplo 1: prueba debajo del código y analiza línea por línea

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

Ejemplo 2: prueba debajo del código y analiza línea por línea

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

Bien, veamos cuál es la diferencia entre mutable e inmutable.

mutable (cambia) vs. inmutable (no puede cambiar)

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

¿¿Alguna otra pregunta?? por favor escribe en ...

Answer 5

En Java, todas las cadenas son inmutables. Cuando intentas modificar una String , lo que realmente estás haciendo es crear una nueva. Sin embargo, cuando utiliza un StringBuilder , en realidad está modificando los contenidos, en lugar de crear uno nuevo.

Answer 6

Java String s son inmutables.

En su primer ejemplo, está cambiando la referencia a la String , asignándole así el valor de otras dos Strings combinadas: str + " Morning" .

Por el contrario, un StringBuilder o StringBuffer se puede modificar a través de sus métodos.

Answer 7

Modifiqué el código de william con unos comentarios de salida para una mejor comprensión

 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
}

En el código anterior, observe el valor de str en main () y changeStr (), aunque cambie el valor de str en changeStr () solo afecta a esa función, pero en la función principal el valor no se cambia, pero no en el caso de StringBuffer ..

En StringBuffer cambió el valor se ve afectado como un mundo ..

por lo tanto, String es inmutable y StringBuffer es mutable ...

En Simple, lo que sea que cambie a String Object afectará solo a esa función yendo a String Pool. pero no cambiado ...

Answer 8

Mutable significa que guardará la misma referencia a la variable y cambiará su contenido, pero inmutable, no puede cambiar el contenido, pero declarará que la nueva referencia contiene el valor nuevo y antiguo de la variable.

Ex inmutable -> cadena

String x = "value0ne";// adresse one x += "valueTwo"; //an other adresse {adresse two} String x = "value0ne";// adresse one x += "valueTwo"; //an other adresse {adresse two} en el cambio de la memoria del montón.

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

sb todavía en la misma dirección espero que este comentario ayude

Answer 9

Una variable mutable es aquella cuyo valor puede cambiar en su lugar, mientras que en una variable inmutable, el cambio de valor no ocurrirá. La modificación de una variable inmutable reconstruirá la misma variable.

Answer 10

es muy fácil de explicar en este enlace con setter y la clase de getter es mutable, mientras que la clase con solo getter es inmutable. Aquí están los detalles. http://latest-tutorial.com/2014/11/14/difference-mutable-immutable-objects-java/

Answer 11

Objetos mutables: cuando tiene una referencia a una instancia de un objeto, el contenido de esa instancia puede ser alterado

Objetos inmutables: cuando tiene una referencia a una instancia de un objeto, el contenido de esa instancia no puede ser alterado

Comprendamos esto con un ejemplo:

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

El resultado de esto es:

old String
new String

Ahora encontramos que el valor mostrado por la variable myString ha cambiado. Hemos definido los objetos inmutables como incapaces de cambiar su valor, entonces, ¿qué está sucediendo? Extendamos el ejemplo nuevamente para ver la variable myString más cerca.

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

El resultado de ejecutar esto es:

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

Lo que esto muestra es que la variable myString hace referencia a una nueva instancia de la clase String. El contenido del objeto no cambió; descartamos la instancia y cambiamos nuestra referencia a una nueva con nuevos contenidos.

Answer 12

• Mutable : - Cambiable
• Immutable : - Immutable

String en Java es inmutable . Sin embargo, lo que significa ser mutable en el contexto de programación es la primera pregunta. Considera seguir la clase,

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

Ahora, después de crear la instancia de Dimension , siempre podemos actualizar sus atributos. Tenga en cuenta que si cualquiera de los atributos, en otro estado de los sentidos, se puede actualizar, por ejemplo, de la clase, entonces se dice que es mutable. Siempre podemos hacer lo siguiente,

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

Veamos de diferentes maneras que podemos crear una Cadena 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 !";
// ...

Asi que,

1. str1 y str2 son literales de cadena que se crean en el grupo de constante de cadena
2. str3 , str4 y str5 son objetos de cadena que se colocan en la memoria Heap
3. str1 = "Hi!"; crea "Hi!" en el conjunto constante de String y es una referencia totalmente diferente de "Hey!" que str1 referencia antes.

Aquí estamos creando el String literal o el String Object. Ambos son diferentes, le sugiero que lea la siguiente publicación para entender más sobre esto.

• Diferencia entre objeto de cadena y literal de cadena

En cualquier declaración de Cadena, una cosa es común, que no se modifica sino que se crea o se desplaza a otra.

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

¿Cómo se volvió inmutable String?

Es un comportamiento que no cambia, significa que el valor una vez asignado no se puede actualizar de ninguna otra manera. La clase de cadena contiene internamente datos en la matriz de caracteres. Además, la clase está creada para ser inmutable. Eche un vistazo a esta estrategia para definir la clase inmutable.

Cambiar la referencia no significa que cambiaste su valor. Sería mutable si puede actualizar la matriz de caracteres que está detrás de la escena en la clase String. Pero en realidad esa matriz se inicializará una vez y durante todo el programa seguirá siendo la misma.

¿Por qué StringBuffer es mutable?

Como ya has adivinado, la clase StringBuffer es mutable, ya que puedes actualizar su estado directamente. Similar a String, también tiene valor en la matriz de caracteres y puede manipular esa matriz mediante diferentes métodos, es decir , agregar, eliminar, insertar, etc., lo que cambia directamente la matriz de valores de caracteres.