¿Cómo maneja Java los objetos de cadena en la memoria?

Me hicieron esta pregunta:

String s = "abc"; // creates one String object and one // reference variable In this simple case, "abc" will go in the pool and s will refer to it. String s = new String("abc"); // creates two objects, // and one reference variable* 

En base a los detalles anteriores, ¿cuántos objetos String y cuántas variables de referencia se crearon antes de la statement de impresión del código siguiente?

 String s1 = "spring "; String s2 = s1 + "summer "; s1.concat("fall "); s2.concat(s1); s1 += "winter "; System.out.println(s1 + " " + s2); 

Mi respuesta fue: El resultado de este fragmento de código es la spring invierno spring verano

Hay dos variables de referencia, s1 y s2. Hubo un total de ocho objetos String creados de la siguiente manera: “spring”, “verano” (perdido), “spring verano”, “otoño” (perdido), “spring otoño” (perdido), “spring verano spring” (perdido ), “invierno” (perdido), “spring invierno” (en este punto se pierde “spring”).

Solo dos de los ocho objetos String no se pierden en este proceso.

¿Es correcto?

La respuesta es: 2 referencias y 8 objetos.

 String s1 = "spring "; //One reference and 1 object in string pool. (if it didn't exist already) String s2 = s1 + "summer "; //Two references and 3 objects s1.concat("fall "); //Two references and 5 objects s2.concat(s1); //Two references and 6 objects s1 += "winter "; //Two references and 8 objects System.out.println(s1 + " " + s2); 

Ahora su pregunta: ¿Cómo maneja Java los objetos de cadena en la memoria?

Java proporciona dos formas de crear objetos de clase String .

  1. String str1 = “OneString”;

En este caso, JVM busca el conjunto de cadenas para ver si ya existe una cadena equivalente. En caso afirmativo, devuelve la referencia al mismo. si no, lo agrega al conjunto de cadenas y devuelve la referencia. Así que un nuevo objeto puede ser creado O puede no serlo.

  1. String str1 = new String (“OneString”);

Ahora, JVM tiene que crear un objeto en el montón. Debido a lo nuevo . no importa si OneString ya está presente en el conjunto de cadenas.

También puede poner una cadena a la piscina:

Puede llamar a intern () en un objeto String. Esto colocará el objeto String en el grupo si aún no está allí y devolverá la referencia a la cadena agrupada. (Si ya estaba en el grupo, simplemente devuelve una referencia al objeto que ya estaba allí).

Es posible que desee ver los siguientes enlaces:

¿Qué es el conjunto de cadenas de Java y en qué se diferencia “s” de la nueva Cadena (“s”)?

Preguntas sobre el grupo de cadenas de Java

Las cuerdas en java son inmutables. Se asigna una matriz de caracteres y parte de la información circundante, como desplazamiento y longitud. En caso de que esté utilizando literales de cadena para inicializar sus cadenas, el comstackdor intenta optimizar y creará solo un objeto de cadena para cada literal, esto es posible porque son inmutables.

Si realiza concatenación o + en cadenas, entonces la nueva cadena se eliminará y los datos se comstackrán juntos (con penalización de rendimiento).

Contrariamente a esto, la creación de una subcadena fuera de la cadena es prácticamente gratuita, no se copiarán datos

 String s = "abc"; // creates one String object and one // reference variable 

Crea un objeto de cadena solo si el objeto no está ya presente en el conjunto de cadenas de constantes.

 String s = new String("abc"); // creates two objects, // and one reference variable* 

En realidad, esto crea solo un objeto en el montón. Agrega este objeto a la agrupación solo si se llama al método intern () en este objeto String.

 String s1 = "spring "; String s2 = s1 + "summer "; s1.concat("fall "); s2.concat(s1); s1 += "winter "; System.out.println(s1 + " " + s2); 

Tu explicación parece estar bien, excepto que tienes una cadena más en System.out.println (). 🙂
Cuando dice (perdido), en realidad significa que ya no es un objeto vivo (la referencia no está presente en la stack).

Parece correcto Esta es una pregunta de examen SCJP por cierto.

concat devuelve una nueva cadena, esto se pierde. El primer s1 se anula con “spring invierno”

Dos cosas que debes saber sobre Strings en Java:

  • Las cuerdas son inmutables (como ya lo explicó usted)
  • Las cadenas pueden residir en el grupo de cadenas. No cada vez que escribes “Verano” se construye un String completamente nuevo, el “Verano” inmutable puede salir de la piscina (depende de la JVM, pero para Oracle, sí lo es). Consulte también: http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/String.html#intern ()

Saludos cristianas