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

Question

me hice 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* 

Basado en datos anteriores cuántos objetos String y el número de variables de referencia fueron creados antes de la sentencia println por debajo de código?

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 resorte del invierno primavera verano

Hay dos variables de referencia, S1 y S2. Hubo un total de ocho objetos de cadena creados de la siguiente manera: "primavera", "verano" (perdido), "primavera verano", "caída" (perdido), "primavera caída" (perdido), "primavera verano primavera" (perdido), "invierno" (perdido), "invierno de primavera" (en este punto "primavera" se pierde).

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

¿Es correcto?

Answer 1

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 funciona la manija objetos de Java cadena en la memoria

Java proporciona dos formas de crear el objeto de la clase String.

1. String str1 = "OneString";

En este caso, JVM busca en el grupo de cadenas para ver si ya existen cadenas equivalentes. si es así, devuelve la referencia a la misma. si no, lo agrega al grupo de cadenas y devuelve la referencia. Así que se puede crear un nuevo objeto O no.

2. String str1 = new String ("OneString");

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

También se puede poner una cadena a la piscina:

Puede llamar pasante() 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 quiera mirar siguientes enlaces:

What is the Java string pool and how is "s" different from new String("s")?

Questions about Java's String pool

Answer 2

Se ve correcto. Esta es una pregunta del examen SCJP por cierto.

concat devuelve una nueva Cadena, esta se pierde. La primera s1 se anula con la "primavera invierno"

dos cosas que usted debe saber acerca de cadenas en Java:

• cadenas son inmutables (como ya se ha explicado por usted)
• Cuerdas pueden residir en la cadena de piscina. No cada vez que escribes "Verano" se construye un String ist completamente nuevo, el "verano" inmutable puede salir del grupo (depende de la JVM, pero para Oracle sí lo está). Ver también: http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/String.html#intern()

Saludos cristianos

Answer 3

cadenas en Java son inmutables. Hay una matriz de caracteres asignada y alguna información circundante como desplazamiento y longitud. En caso de que esté utilizando cadenas literales para inicializar sus cadenas, el compilador intenta optimizar y creará solo un objeto de cadena para cada literal, esto es posible porque son inmutables.

Si lo hace concatenación o + en cadenas, a continuación, nueva cadena se alloacted y datos compied juntos (con penalización en el rendimiento

Contrariamente a esto, la creación de subcadena de la cadena está prácticamente libre -. Se copiará ningún dato

Answer 4

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

crea un objeto de cadena sólo si el objeto no se presenta en la cadena piscina constante ya .

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

Esto realmente crea solo un objeto en el montón. Agrega este objeto al conjunto si y solo si se llama al método interno() en este objeto String.

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

Usted explicación parece bien, excepto que tiene una cadena de más de System.out.println(). :-)
Cuando dice (perdida) que en realidad significa que no es objeto directo (referencia no está presente en la pila).