-
s = new String("xyz"); ¿Cuántos objetos String se crean? Dos objetos, uno es "xyx" y el otro es el objeto de referencia que apunta a "xyx".
String s="Hello";int i=3; s=i+s; ¿Es correcta esta expresión? En Java, indicará que el tipo de datos no coincide. ¡Porque string es una clase! Enfoque correcto: s+="3" or s+='3' or s+=(char)i;
Vamos a presentar otra forma de crear objetos String: texto entre comillas. Este método es exclusivo de String y es muy diferente del nuevo método.
Hay un grupo de cadenas en la máquina virtual JAVA (JVM), que almacena muchos objetos String y se puede compartir, por lo que mejora la eficiencia. String a="abc";, cuando se ejecuta esta línea de código, la máquina virtual JAVA primero busca en el grupo de cadenas para ver si dicho objeto con el valor "abc" ya existe. La base para juzgar es que la clase String es igual a (Objeto). obj) El valor de retorno del método. Si lo hay, no se creará ningún objeto nuevo y se devolverá directamente una referencia al objeto existente; de lo contrario, el objeto se creará primero, luego se agregará al grupo de cadenas y luego se devolverá su referencia.
Creación de objetos de cadena: debido al uso extensivo de objetos de cadena [es un objeto, en términos generales, los objetos siempre asignan memoria en el montón], en Java, para ahorrar espacio de memoria y tiempo de ejecución [como al comparar cadenas, == es mejor que igual ()], todos los literales de cadena se colocan en un grupo de literales durante la fase de compilación, y el grupo de literales en tiempo de ejecución se convierte en parte del grupo constante. La ventaja del grupo literal es que todas las mismas constantes de cadena en el grupo se fusionan y solo ocupan un espacio. Sabemos que para dos variables de referencia, use == para determinar si sus valores [referencias] son iguales, es decir, apuntan al mismo objeto:
Ahora mire la instrucción String s = new String("abc"); Aquí "abc" en sí es un objeto en el grupo, y cuando se ejecuta new String() en tiempo de ejecución, se coloca una copia del objeto en el grupo. en el montón y entregar la referencia de este objeto en el montón a s. Bien, esta declaración crea 2 objetos String.
String s1 = new String("abc") ;String s2 = new String("abc") ;if( s1 == s2 ){ //Declaración que no se ejecutará}
// ¿Cuántos objetos de cadena se crearon? [Tres, uno en el grupo y dos en el montón. ]
Solo se agregarán al grupo de cadenas los objetos nuevos generados por la conexión "+" entre objetos de cadena creados usando comillas para incluir texto. Para todas las expresiones de conexión "+" que contienen nuevos objetos creados en el nuevo método (incluido nulo), los nuevos objetos que generan no se agregarán al grupo de cadenas.
1.== significa que se hace referencia a ellos desde el mismo objeto, y igual () significa que los valores son iguales.
String str1 = "abc"; el objeto al que se hace referencia está en la pila (o grupo de cadenas).
String str1 =new String ("abc"); El objeto referenciado está en la memoria/montón.
2.String str1 = "cadena";
Cadena str3 = "cadena";
Cadena str4 = "ing";
String str2 = str3+str4; en el montón, porque la función del signo + es devolver otro objeto String recién creado en lugar de buscar el valor de la cadena en la pila. Si es String str2 = "str"+"ing"; entonces el resultado final está en la pila. str1==str2 es verdadero.
Pero hay una situación que exige nuestra atención. Por favor mire el código a continuación:
clase pública StringStaticTest {
cadena final estática pública A = "ab" // constante A
cadena final estática pública B = "cd" // constante B
público estático vacío principal (String [] argumentos) {
String s = A + B; // Inicializa s conectando las dos constantes con +
Cadena t = "abcd";
si (s == t) {
System.out.println("s es igual a t, son el mismo objeto");
} demás {
System.out.println("s no es igual a t, no son el mismo objeto");
}
}
}
El resultado de ejecutar este código es el siguiente:
s es igual a t, son el mismo objeto
La razón es que en el ejemplo anterior, A y B son constantes y sus valores son fijos, por lo que el valor de s también es fijo y se determina cuando se compila la clase. Es decir: String s=A+B es equivalente a: String s="ab"+"cd";
Permítanme cambiar ligeramente el ejemplo anterior y ver qué sucede:
clase pública StringStaticTest {
cadena final estática pública A; // constante A;
cadena final estática pública B // constante B
estático {
A = "ab";
B = "cd";
}
público estático vacío principal (String [] argumentos) {
// Inicializa s conectando las dos constantes con +
Cadena s = A + B;
Cadena t = "abcd";
si (s == t) {
System.out.println("s es igual a t, son el mismo objeto");
} demás {
System.out.println("s no es igual a t, no son el mismo objeto");
}
}
}
El resultado de su funcionamiento es este:
s no es igual a t, no son el mismo objeto
Acabo de hacer un pequeño cambio y el resultado es exactamente el opuesto al ejemplo de ahora. Analicémoslo de nuevo. Aunque A y B se definen como constantes (solo se pueden asignar una vez), no se asignan inmediatamente. Antes de calcular el valor de s, cuándo se asignan y qué valor se les asigna son todas variables. Por lo tanto, A y B se comportan como una variable antes de que se les asigne un valor. Entonces s no se puede determinar en tiempo de compilación, solo se puede crear en tiempo de ejecución.
Finalmente, hablemos sobre el almacenamiento de objetos String en la Máquina Virtual JAVA (JVM) y la relación entre el grupo de cadenas y el montón y la pila. Primero revisemos la diferencia entre montón y pila:
Pila: guarda principalmente tipos básicos (o tipos integrados) (char, byte, short, int, long, float, double, boolean) y las referencias de objetos se pueden compartir, y su velocidad es solo superada por el registro. montón.
Montón: utilizado para almacenar objetos.
Cuando miramos el código fuente de la clase String, encontraremos que tiene un atributo de valor, que almacena el valor del objeto String. El tipo es char [], lo que también muestra que una cadena es una secuencia de caracteres. Al ejecutar String a="abc";, la máquina virtual JAVA crea tres valores de caracteres 'a', 'b' y 'c' en la pila, y luego crea un objeto String en el montón, su valor (valor) es una matriz de tres valores de caracteres recién creados en la pila {'a', 'b', 'c'}. Finalmente, el objeto String recién creado se agregará al grupo de cadenas.
Si luego ejecutamos el código String b=new String("abc"); dado que "abc" se creó y guardó en el grupo de cadenas, la máquina virtual JAVA solo creará un nuevo objeto String en el montón, pero es The. El valor son los tres valores de tipo char 'a', 'b' y 'c' creados en la pila cuando se ejecutó la línea de código anterior.
En este punto, ya tenemos bastante clara la pregunta de por qué String str=new String("abc") planteada al principio de este artículo crea dos objetos.
Este artículo proviene del blog de CSDN. Indique la fuente al reimprimir: http://blog.csdn.net/yakihappy/archive/2009/03/10/3977169.aspx.
Este artículo proviene del blog de CSDN. Indique la fuente al reimprimir: http://blog.csdn.net/Foxalien/archive/2009/12/18/5029470.aspx.
-