Inmutabilidad de cadenas en Java

Considere el siguiente ejemplo.

String str = new String();

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

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

Ahora, en Java, los objetos String son inmutables. Entonces, ¿cómo strpuede asignarse el valor del objeto "Ayuda!". ¿No contradice esto la inmutabilidad de las cadenas en Java? ¿Alguien puede explicarme el concepto exacto de inmutabilidad?

Editar:

Okay. Ahora lo entiendo, pero solo una pregunta de seguimiento. ¿Qué pasa con el siguiente código:

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

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

¿Significa esto que se crean dos objetos nuevamente ("Mississippi" y "M! Ss! Ss! Pp!") Y los strpuntos de referencia a un objeto diferente después del replace()método?

strno es un objeto, es una referencia a un objeto. "Hello"y "Help!"son dos Stringobjetos distintos . Por lo tanto, str apunta a una cadena. Puede cambiar lo que apunta , pero no lo que apunta .

Tome este código, por ejemplo:

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

Ahora, no hay nada ¹ que podríamos hacer para s1que afectaría el valor de s2. Se refieren al mismo objeto, la cadena "Hello", pero ese objeto es inmutable y, por lo tanto, no se puede modificar.

Si hacemos algo como esto:

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

Aquí vemos la diferencia entre mutar un objeto y cambiar una referencia. s2todavía apunta al mismo objeto que inicialmente configuramos s1para apuntar. Ajuste s1a "Help!"sólo cambia la referencia , mientras que el Stringobjeto al que se refería originalmente a los restos sin cambios.

Si las cadenas fueran mutables, podríamos hacer algo como esto:

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"

Editar para responder a la edición de OP:

Si mira el código fuente de String.replace (char, char) (también disponible en src.zip en su directorio de instalación de JDK, un consejo profesional es buscar allí cada vez que se pregunte cómo funciona realmente algo), puede ver que lo que hace es lo siguiente:

• Si hay una o más ocurrencias de oldCharen la cadena actual, haga una copia de la cadena actual donde oldCharse reemplazan todas las ocurrencias de newChar.
• Si oldCharno está presente en la cadena actual, devuelva la cadena actual.

Entonces sí, "Mississippi".replace('i', '!')crea un nuevo Stringobjeto. De nuevo, lo siguiente es válido:

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

Su tarea por ahora es ver qué hace el código anterior si cambia s1 = s1.replace('i', '!');a s1 = s1.replace('Q', '!');:)

¹ En realidad, es posible mutar cadenas (y otros objetos inmutables). Requiere reflexión y es muy, muy peligroso y nunca debe usarse a menos que esté realmente interesado en destruir el programa.

El objeto al que hace strreferencia puede cambiar, pero los Stringobjetos en sí mismos no pueden.

Los Stringobjetos que contienen la cadena "Hello"y "Help!"no pueden cambiar sus valores, por lo tanto, son inmutables.

La inmutabilidad de los Stringobjetos no significa que las referencias que apuntan al objeto no puedan cambiar.

Una forma de evitar que strcambie la referencia es declararla como final:

final String STR = "Hello";

Ahora, intentar asignar otro Stringa STRprovocará un error de compilación.

Light_handle Le recomiendo que lea el tamaño de la copa, una historia sobre variables y valor de paso por favor (tamaño de la copa, continuación) . Esto ayudará mucho al leer las publicaciones anteriores.

¿Los has leído? Si. Bueno.

String str = new String();

Esto crea un nuevo "control remoto" llamado " str" y lo establece en el valor new String()(o "").

Por ejemplo, en la memoria esto crea:

str --- > ""

str  = "Hello";

Esto cambia el control remoto " str" pero no modifica la cadena original "".

Por ejemplo, en la memoria esto crea:

str -+   ""
     +-> "Hello"

str = "Help!";

Esto cambia el control remoto " str" pero no modifica la cadena original ""ni el objeto al que apunta actualmente el control remoto.

Por ejemplo, en la memoria esto crea:

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

Vamos a dividirlo en algunas partes

String s1 = "hello";

Esta instrucción crea una cadena que contiene hola y ocupa espacio en la memoria, es decir, en Constant String Pool y lo asigna al objeto de referencia s1

String s2 = s1;

Esta declaración asigna la misma cadena de saludo a la nueva referencia s2

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

Ambas referencias apuntan a la misma cadena, por lo que genera el mismo valor de la siguiente manera.

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

Aunque String es inmutable , la asignación puede ser posible, por lo que s1 ahora se referirá a una nueva pila de valores .

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

Pero, ¿qué pasa con el objeto s2 que apunta a hola? Será como es.

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

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

Como String es inmutable, Java Virtual Machine no nos permitirá modificar la cadena s1 por su método. Creará todos los nuevos objetos String en el grupo de la siguiente manera.

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

Tenga en cuenta que si String sería mutable, la salida habría sido

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

Ahora te sorprenderá por qué String tiene métodos como concat () para modificar. El siguiente fragmento borrará tu confusión.

s1 = s1.concat(" overflow");

Aquí estamos asignando el valor modificado de la cadena de nuevo a la referencia s1 .

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


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

Es por eso que Java decidió que String sea una clase final. De lo contrario, cualquiera puede modificar y cambiar el valor de string. Espero que esto ayude un poco.

El objeto de cadena al que primero se hizo referencia strno se modificó, todo lo que hizo fue hacer strreferencia a un nuevo objeto de cadena.

La cadena no cambiará, la referencia a ella sí. Estás confundiendo la inmutabilidad con el concepto de finalcampos. Si un campo se declara como final, una vez que se ha asignado, no se puede reasignar.

Con respecto a la parte de reemplazo de su pregunta, intente esto:

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!

Aunque Java intenta ignorarlo, strno es más que un puntero. Esto significa que cuando escribe por primera vez str = "Hello";, crea un objeto que strapunta. Cuando reasignas strpor escrito str = "Help!";, se crea un nuevo objeto y el "Hello"objeto viejo se recolecta cuando cada vez que Java lo desee.

La inmutabilidad implica que el valor de un objeto instanciado no puede cambiar, nunca puede convertir "Hola" en "¡Ayuda!".

La variable str es una referencia a un objeto, cuando asigna un nuevo valor a str no está cambiando el valor del objeto al que hace referencia, está haciendo referencia a un objeto diferente.

La clase de cadena es inmutable y no puede cambiar el valor del objeto inmutable. Pero en el caso de String, si cambia el valor de string, creará una nueva cadena en el grupo de cadenas y su referencia de cadena a ese valor no al anterior. por lo tanto, la cadena es inmutable. Tomemos tu ejemplo,

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

creará una cadena "Mississippi" y la agregará al conjunto de cadenas, por lo que ahora str apunta a Mississippi.

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

Pero después de la operación anterior, se creará una cadena "M! Ss! Ss! Pp!" y se agregará al conjunto de cadenas. y ahora str apunta a M! ss! ss! pp !, no a Mississippi.

así, cuando altere el valor del objeto de cadena, creará un objeto más y lo agregará al grupo de cadenas.

Vamos a tener un ejemplo más.

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

esta línea de arriba agregará tres objetos de cadena al conjunto de cadenas.
1) Hola
2) Mundo
3) Hola Mundo

Utilizar:

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

Si ve aquí, uso el concatmétodo para cambiar la cadena original, es decir, "Nueva cadena" con una cadena "Cadena agregada", pero aún así obtuve la salida como anterior, por lo tanto, demuestra que no puede cambiar la referencia del objeto de la clase String, pero si hace esto mediante la clase StringBuilder, funcionará. Se enumera a continuación.

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

Como dijo Linus Tolvards:

Hablar es barato. Muéstrame el código

Mira esto:

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 salida es

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

Entonces, recuerda dos cosas:

• Las cadenas son inmutables hasta que aplique un método que manipule y cree uno nuevo (casos de c & d).
• El método Reemplazar devuelve el mismo objeto String si ambos parámetros son iguales

Para aquellos que se preguntan cómo romper la inmutabilidad de String en Java ...

Código

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

    }
}

Salida

true
I am   mutable
I am   mutable

La cadena es inmutable . Lo que significa que solo podemos cambiar la referencia .

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, a los objetos generalmente se accede por referencias. En su fragmento de código, str es una referencia que primero se asigna a "Hola" (un objeto creado automáticamente o obtenido de un grupo constante ) y luego se le asigna otro objeto "¡Ayuda!" a la misma referencia. Un punto a tener en cuenta es que la referencia es la misma y modificada, pero los objetos son diferentes. Una cosa más en tu código accediste a tres objetos,

1. Cuando llamaste a nuevo String ().
2. Cuando asignaste "hola".
3. Cuando asignaste "ayuda".

Llamar a una nueva cadena () crea un nuevo objeto incluso si existe en el grupo de cadenas, por lo que generalmente no debe usarse. Para poner una cadena creada a partir de la nueva cadena () en el grupo de cadenas, puede probar el intern()método.

Espero que esto ayude.

La inmutabilidad que puedo decir es que no se puede cambiar la cadena en sí. Supongamos que tiene String x, cuyo valor es "abc". Ahora no puede cambiar la cadena, es decir, no puede cambiar ningún carácter / s en "abc".

Si tiene que cambiar los caracteres en la Cadena, puede usar una matriz de caracteres y mutarla o usar 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);

Salida:

hj
sj

O puedes probar:

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

Esto mostrará cómo cambia el código hash.

La cadena es inmutable significa que no puede cambiar el objeto en sí, pero puede cambiar la referencia al objeto. Cuando llamaste a = "ty", en realidad estás cambiando la referencia de a a un nuevo objeto creado por la cadena literal "ty". Cambiar un objeto significa usar sus métodos para cambiar uno de sus campos (o los campos son públicos y no finales, para que puedan actualizarse desde el exterior sin acceder a ellos a través de métodos), por ejemplo:

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

Mientras está en una clase inmutable (declarada como final, para evitar la modificación por herencia) (sus métodos no pueden modificar sus campos, y también los campos son siempre privados y se recomienda que sean finales), por ejemplo String, no puede cambiar la String actual pero puede devolver una nueva cadena, es decir:

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"

Aquí la inmutabilidad significa que la instancia puede apuntar a otra referencia, pero el contenido original de la cadena no se modificaría en la referencia original. Déjame explicarte con el primer ejemplo dado por ti. El primer str apunta a "Hola", está bien hasta esto. La segunda vez apunta a "¡Ayuda!". Aquí str comenzó a señalar "¡Ayuda!" y la referencia de la cadena "Hola" se pierde y no podemos recuperarla.

De hecho, cuando str intentaría modificar el contenido existente, se generará otra nueva cadena y str comenzará a apuntar a esa referencia. Entonces, vemos que la cadena en la referencia original no se modifica, pero eso es seguro en su referencia y la instancia del objeto comenzó a apuntar a una referencia diferente para conservar la inmutabilidad.

Súper tarde a la respuesta, pero quería poner un mensaje conciso del autor de la clase String en Java

Las cuerdas son constantes; sus valores no se pueden cambiar después de que se crean. Los amortiguadores de cadena admiten cadenas mutables. Como los objetos de cadena son inmutables, se pueden compartir.

Se puede deducir de esta documentación que cualquier cosa que cambie la cadena, devuelva un objeto diferente (que podría ser nuevo o interno y antiguo). La pista no tan sutil sobre esto debería provenir de la firma de la función. Piénselo: "¿Por qué hicieron que una función en un objeto devolviera un objeto en lugar de un estado?".

public String replace(char oldChar, char newChar) 

También una fuente más que hace explícito este comportamiento (de la documentación de la función de reemplazo)

Devuelve una nueva cadena resultante de reemplazar todas las apariciones de oldChar en esta cadena con newChar.

Fuente: 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

Fuente: JavaDoc de String.

La cadena Object - los métodos en sí mismos están hechos para ser "inmutables". Esta acción no produce cambios: "letters.replace (" bbb "," aaa ");"

Pero la asignación de datos causa cambios en el contenido de Strings:

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

// El hashcode de la cadena Object no cambia.

Si HELLOes la cadena de entonces no se puede cambiar HELLOa HILLO. Esta propiedad se llama propiedad de inmutabilidad.

Puede tener una variable de cadena de puntero múltiple para apuntar HOLA cadena.

Pero si HOLA es char Array, entonces puedes cambiar HOLA a HILLO. P.ej,

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

Los lenguajes de programación tienen variables de datos inmutables para que puedan usarse como claves en clave, par de valores.

Lo explicaría con un simple ejemplo

considere cualquier conjunto de caracteres: por ejemplo, char a [] = {'h', 'e', ​​'l', 'l', 'o'}; y una cadena: String s = "hola";

en la matriz de caracteres podemos realizar operaciones como imprimir solo las últimas tres letras usando iterar la matriz; pero en cadena tenemos que hacer un nuevo objeto de cadena y copiar la subcadena requerida y su dirección estará en un nuevo objeto de cadena.

p.ej

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

entonces s2 tendrá "hel";

La cadena en Java en Inmutable y Final solo significa que no se puede cambiar ni modificar:

Caso 1:

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

Salida: ABC

Motivo: la referencia de objeto str no se modifica; de hecho, se crea un nuevo objeto "DEF" que está en el grupo y no tiene ninguna referencia (es decir, se pierde).

Caso 2:

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

Salida: ABCDEF

Motivo: En este caso, str ahora se refiere a un nuevo objeto "ABCDEF", por lo tanto, imprime ABCDEF, es decir, el objeto str anterior "ABC" se pierde en el grupo sin referencia.

Debido a que String es inmutable, los cambios no ocurrirán si no asigna el valor devuelto de la función a la cadena. Por lo tanto, en su pregunta, asigne el valor de la función de intercambio devuelto a s.

s = swap (s, n1, n2); entonces el valor de la cadena s cambiará.

También estaba obteniendo el valor sin cambios cuando estaba escribiendo el programa para obtener una cadena de permutaciones (aunque no está dando todas las permutaciones, pero esto es, por ejemplo, para responder a su pregunta)

Aquí hay un ejemplo.

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

pero no estaba obteniendo los valores permutados de la cadena del código anterior, así que asigné el valor devuelto de la función de intercambio a la cadena y obtuve valores cambiados de la cadena. Después de asignar el valor devuelto obtuve los valores permutados de cadena.

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

Producirá poner algo como esto

1419358369 1419358369

103056 65078777

El propósito del objeto inmutable es que su valor no debe modificarse una vez asignado. Devolverá un nuevo objeto cada vez que intente alterarlo según la implementación. Nota: Stringbuffer en lugar de string puede usarse para evitar esto.

A su última pregunta :: u tendrá una referencia y 2 cadenas en el grupo de cadenas. Excepto que la referencia apuntará a m! Ss! Ss! Pp!